技術文章 » Shiro安全框架（Shiro與SpringBoot整合開發）

Shiro安全框架（Shiro與SpringBoot整合開發）

2020-10-21 11:00:44

 

 

一、整合的思路

繼上次說完了Shiro中的授權之後，Shiro中的認證和授權就全部為大家講解完了，相信大家是跟著前兩篇文章看過來的對Shiro在程式中進行認證和授權的操作都已經略知一二了，下面就為大家講解一下Shiro在SpringBoot中的應用整合，同時在之前我們做的認證授權都是在程式碼中寫死直接寫死的，而在我們這次與SpringBoot的整合開發中，將會使用資料庫中的資料來替代程式碼中的資料，更加真實的模擬我們日常在工作中對許可權控制開發。

首先我們不論是開發任何功能，都是要對需求和思路進行清晰透徹的梳理和理解，雖然我們本次開發是模擬的真實開發場景，我們也要對開發之前的需求，實現的流程進行梳理。下面先為大家展示一張流程圖，之後我會通過整張流程圖再來講解Shiro與SpringBoot整合開發的思路。

首先，我們要開發許可權第一步是要先有一個SpringBoot的應用，這個我們做許可權是對SpringBoot應用中的所有資源進行保護，如圖所示，一個頁面可以是一個被保護的資源。同樣，程式中的一個方法也可以是一個被保護的資源，但是在一個SpringBoot的應用中，不僅僅要有被保護的資源，還要有公共資源，因為我們如果沒有公共資源，登入或者註冊的頁面就沒有辦法被使用者存取到，那假如說連註冊和登入都是被保護起來的資源，那我們這個系統又怎麼用呢？

所以門將所有的系統資源分為了兩大類，一類是公共資源例如：登入頁、登入的方法、註冊頁、註冊的方法、可能還會有找回密碼等等的這些統一劃分為公共資源，而例如主頁，或對系統內部資料的增刪改查等的操作就被劃分為受限資源，此時這些資源就要被我們用Shiro做的許可權驗證來保護起來。

前面我們說了那麼多怎麼把系統分為受限資源，公共資源，怎麼用Shiro對他們進行許可權的保護，但這些都有一個大的前提，必須讓Shiro拿到SpringBoot應用中的所有的請求，為什麼呢？應用中的所有資源都是通過客戶通過一個又一個的請求來存取的，假如說我們的Shiro連請求都拿不到，又何談劃分資源何談保護資源呢，所以所有的請求過來，首先要經過一個過濾器。對請求分類，看是受限資源還是公共資源，如果是公共資源不需要認證則直接放行，如果是受限資源呢？受限資源受限經過SecurityManager這個類進行認證處理，從我們的自定義Realms中拿到資料，同時Realms中還會有一系列的密碼憑證匹配器，三列次數，演演算法名稱等等一系列的操作。認證通過之後還要進行授權的操作，也就是說雖然你通過了認證，但是我們的Shiro還要來看看你是否有操作這個資源的許可權，這樣也就達到了相對細粒度的許可權控制。

好了經過上面的一張流程圖的展示以及對圖的解釋，我相信大家已經對流程有了相應的瞭解，下面就可以進行實戰開發了。

二、環境搭建

首先上專案目錄結構

 POM檔案<這時還沒有引入Shiro>

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.csdn</groupId>
    <artifactId>springboot_shiro_jsp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_shiro_jsp</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--jsp解析的依賴-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!--可能會在jsp中用到c標籤-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.properties

#指定埠號
server.port=8090
#請求路徑中加上專案名
server.servlet.context-path=/shiro
#指定專案名
spring.application.name=shiro

#將mvc檢視改為jsp，字首、字尾
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

 在新建的webapp中新建一個index.jsp：

在IDEA中設定它的工作目錄：

接下來啟動，看一下效果：

好的，這樣基本的springboot的一個應用就搭建起來了。

三、將Shiro與SpringBoot應用進行整合

Shiro與Springboot整合首先在專案目錄中新建一個config包用來放專案中的各種設定類，之後編寫一個類名叫ShiroConfig表明是Shiro的設定類，因為以後再專案中也許會放很多設定類，所以要見名知意表明是shiro的設定類。首先我們先將ShiroConfig的架子搭起來，具體程式碼如下：

/**
 * 用來整合shiro與springboot的設定類  關係就是一層依賴一層
 */
@Configuration
public class ShiroConfig {

    //建立ShiroFilter過濾器          負責攔截所有請求
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //給過濾器設定安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }

    //建立安全管理器
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = newDefaultWebSecurityManager(realm);
        //給安全管理器設定realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //建立自定義Realm
    @Bean
    public Realm realm(){
        MyRealm myRealm = new MyRealm();
        return myRealm;
    }
}

從上面的程式碼中可以看到最後一個為自定義Realm，那麼我們也來新建一個名叫ralms的包。用來存放我們的自定義Realm：

/*
 * 自定義Realm
 */
public class MyRealm extends AuthorizingRealm {
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        return null;
    }
}

那麼現在一個簡單的架子我們就搭起來了，下面來完成具體實現。

那麼雖然我們現在已經將架子搭建起來了，但是我們並沒有在shiroconfig中寫出來那些請求需要認證那些請求直接放行，所以所有的頁面都能被存取到，現在就來看看具體實現。

四、具體實現

首先來看的是設定ShiroFilterFactoryBean設定受限資源和登入頁路徑：


    //建立ShiroFilter過濾器          負責攔截所有請求
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = shiroFilterFactoryBean(defaultWebSecurityManager);
        //宣告一個map
        Map<String,String> map = new HashMap<>();
        //設定系統受限資源
        map.put("/index.jsp","authc"); //authc: 代表請求這個資源需要認證和授權
        //預設的登入頁面路徑
        shiroFilterFactoryBean.setLoginUrl("login.jsp"); //因為shiro與jsp的整合相對友好，所以這個路徑如果不寫也會預設去找，但也可以改變
        //將宣告路徑的map設定給過濾器
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);

        //給過濾器設定安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }

如上程式碼所示，如果設定了頁面路徑+autch，則視為此頁面路徑為受保護的資源頁面，如果存取這個頁面需要認證和授權，並且如果在同級目錄下有一個login.jsp的頁面會重定向到login.jsp並不需要設定，同時，如果你的login.jsp頁面不在統計目錄下或者叫其他名字，你也可以通過setLoginUrl的方式來設定你的登入頁面來進行跳轉。

那麼authc這個在map中的value是什麼呢？實際上這個authc是shiro為我們提供的一個過濾器的簡稱，其實還有很多簡稱下面為大家貼一張圖：

雖然有很多過濾器但是最常用的也就是anon和authc這兩種，如果日後想用其他的過濾器只需要根據自己的不同需求來選擇不同功能的過濾器即可。

使用者登入

接著我們再來編寫一個簡單的登入頁面：

接著來編寫一個controller：

@RequestMapping("/user")
@Controller
public class UserController {
    /**
     * 處理身份認證
     * @param username
     * @param password
     * @return
     */
    @RequestMapping("/login")
    public String login(String username,String password){
        //獲取主體物件
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken(username,password);
        try {
            subject.login(token);
            return "redirect:/index.jsp";
        } catch (IncorrectCredentialsException e) {
            e.printStackTrace();
            System.out.println("密碼錯誤");
        } catch (UnknownAccountException e) {
            e.printStackTrace();
            System.out.println("使用者名稱錯誤");
        }
        return "redirect:/login.jsp";
    }

此時我們編寫完畢這個controller之後他一定會走我們的自定義Realm，但是此時我們的自定義Realm並沒有寫任何的具體實現所以不論我們怎麼存取他都會重定向至登入頁面：

那暫時我們寫再將認證資訊寫死在程式碼中，測試一下：

/*
 * 自定義Realm
 */
public class MyRealm extends AuthorizingRealm {
    /**
     * 授權
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    /**
     * 認證
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        if (principal.equals("zhangsan")){
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(principal,"123",this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

此時我將認證的資訊固定為使用者名稱：zhangsan 密碼：123 再來測試一下：

效果：

進入了被保護的資源頁面，系統主頁。

那麼此時還有一個問題，那以後我們所設計的系統一定不會只有這兩個頁面，一定會有很多被保護的頁面，如果挨個去設定會跟麻煩，那麼我們怎麼辦呢？這樣的話就可以將一些比較少的公共資源設定為放行，將其他所有的頁面設定為 /**，來將其保護起來。但一定要切記，公共資源的程式碼順序一定是在被保護的資源的程式碼上方。

如下修改ShiroConfig：

/**
 * 用來整合shiro與springboot的設定類  關係就是一層依賴一層
 */
@Configuration
public class ShiroConfig {

    //建立ShiroFilter過濾器          負責攔截所有請求
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //宣告一個map
        Map<String,String> map = new HashMap<>();
        //設定公共資源
        map.put("/login.jsp","anon"); //anon:代表這個資源為公共資源
        //設定系統受限資源
        map.put("/**","authc"); //authc: 代表請求這個資源需要認證和授權
        //將路徑設定給過濾器
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        //預設的登入頁面路徑
        shiroFilterFactoryBean.setLoginUrl("login.jsp"); //因為shiro與jsp的整合相對友好，所以這個路徑如果不寫也會預設去找，但也可以改變


        //給過濾器設定安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }

    //建立安全管理器
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager(realm);
        //給安全管理器設定realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //建立自定義Realm
    @Bean
    public Realm realm(){
        MyRealm myRealm = new MyRealm();
        return myRealm;
    }
}

效果我就不展示了，與上面一樣。

使用者登出

退出登入功能，首先將頁面完善：

然後在UserController中編寫退出的功能：


    /**
     * 使用者登出功能
     * @return
     */
    @RequestMapping("/logout")
    public String logout(){
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.logout();
            return "redirect:/login.jsp";
        } catch (Exception e) {
            e.printStackTrace();
            return "redirect:/index.jsp";
        }
    }

 shiro有一個好處就是如果你重新啟動的話他也會在快取中快取你的登入資訊，所以退出功能就是將之前的快取資訊清除掉，之後再存取資源頁面時就退重定向到登入的頁面。

那麼本篇文章要講的是shiro與springboot的整合開發模擬真實的開發場景，也就是說在真實的開發中我們一定不可能將使用者的資訊寫死在程式碼中，一定是需要去資料庫中獲取使用者的認證資料來實現認證，那麼下面就為大家進一步的整合。

五、連線資料庫進行認證處理

首先，連線資料庫進行認證，我們需要有一個註冊的頁面，實現使用者註冊，同時我們要在使用者註冊的時候所填寫的明文密碼在儲存資料庫之前使用shiro提供的md5加密演演算法、並且加鹽處理之後才能儲存到資料庫中。只有這樣才能在之後進行認證的時候讀出使用者的加密密碼。

使用者註冊（使用者資訊儲存）

先來編寫一個簡單的註冊頁面：

此時使用者註冊時需要涉及到資料庫的儲存那麼我們就來建立一個資料庫，新建一張表來儲存使用者名稱以及密碼。

id欄位自增，然後分別有三個欄位使用者名稱、密碼以及鹽的資訊，之前我們說過加在密碼中的鹽一定要儲存到資料庫中去，只有這樣才能保證我們在認證的時候加入相同的鹽保證使用者認證資訊的通過。

既然我們需要用到隨機鹽那麼我們就需要用到一個鹽工具類那麼我們在工程下的utils包中先來編寫一個鹽工具類：


/**
 * 隨機鹽工具類
 */
public class SaltUtils {

    public String getSalt(int n) {
        //首先定義一個char陣列
        char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890!@#$%^&*()".toCharArray();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            //每次拿到一個隨機字元
            char aChar = chars[new Random().nextInt(chars.length)];
            //拼接隨機字元
            sb.append(aChar);
        }
        return sb.toString();
    }

    /**
     * 測試隨機鹽工具類
     * @param args
     */
    public static void main(String[] args) {
        SaltUtils saltUtils = new SaltUtils();
        String salt = saltUtils.getSalt(8);
        System.out.println(salt);
    }
}

修改之後的POM檔案：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.csdn</groupId>
    <artifactId>springboot_shiro_jsp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_shiro_jsp</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--jsp解析的依賴-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
        <!--可能會在jsp中用到c標籤-->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
        <!--shiro與SpringBoot整合的依賴-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring-boot-starter</artifactId>
            <version>1.6.0</version>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.49</version>
        </dependency>
        <!--mybatis相關的依賴-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>
        <!--druid資料庫連線池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
            </plugin>
        </plugins>
    </build>

</project>

新建一個實體類：

@Data
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private String id;
    private String username;
    private String password;
    private String salt;
}

接著對專案的application.properties檔案進行修改：

#指定埠號
server.port=8090
#請求路徑中加上專案名
server.servlet.context-path=/shiro
#指定專案名
spring.application.name=shiro

#將mvc檢視改為jsp，字首、字尾
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

#資料來源相關設定
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#資料來源型別
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/shiro?characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=root
mybatis.mapper-locations=classpath:com/csdn/mappers/*.xml

相關設定寫完後就可以來編寫註冊的方法並將使用者的資料儲存在資料庫中。

dao層程式碼：

@Mapper
public interface UserDao {
    /**
     * 使用者註冊，儲存
     * @param user
     */
    void save(User user);
}

service層程式碼：

public interface UserService {
    /**
     * 使用者註冊儲存資訊
     * @param user
     */
    void save(User user);
}

serviceImpl層程式碼：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    /**
     * 使用者註冊儲存使用者資訊
     * @param user
     */
    @Override
    public void save(User user) {
        //獲取隨機鹽
        String salt = new SaltUtils().getSalt(8);
        //拿到使用者輸入的密碼
        String password = user.getPassword();
        //新建一個md5Hash的物件傳參
        Md5Hash md5Hash = new Md5Hash(password,salt,1024);
        //s 即為處理後的密碼
        String s = md5Hash.toHex();
        //儲存
        user.setPassword(s);
        user.setSalt(salt);
        userDao.save(user);
    }
}

上面業務層的程式碼主要是對密碼的處理，一方面是獲取隨機鹽，然後儲存隨機鹽，另一方面則是將輸入的密碼獲取到之後進行加密處理後再將其密碼進行儲存。

controller層程式碼：

 /**
     * 使用者註冊
     * @param user
     * @return
     */
    @RequestMapping("/register")
    public String Register(User user){
        try {
            userService.save(user);
            return "redirect:/login.jsp";
        } catch (Exception e) {
            e.printStackTrace();
            return "redirect:/register.jsp";
        }
    }
}

儲存成功後直接重定向到登入頁面，如果報錯之後則在原頁面。

mapper.xml檔案：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.csdn.springboot_shiro_jsp.moudles.user.login.dao.UserDao">
    <insert id="save" useGeneratedKeys="true" keyProperty="id" parameterType="com.csdn.springboot_shiro_jsp.moudles.user.login.pojo.User">
        insert into t_user values(#{id},#{username},#{password},#{salt})
    </insert>
</mapper>

執行過程就不展示了，直接到資料庫去檢視一下結果，我輸入的是：使用者名稱：zhangsan 密碼：123456，資料庫截圖：

使用者資訊認證

現在我們已經將註冊之後的使用者資訊用md5的方式加密並加鹽雜湊1024次之後將密碼以及隨機鹽的內容存入了資料庫中，現在只需要將使用者資訊讀取之後以相同的方式解密認證即可。

首先我們先編寫dao層因為需要一個根據使用者輸入的使用者名稱來獲取使用者資訊的方法，所以首先編寫一個dao層的程式碼以及mapper檔案：

@Mapper
public interface UserDao {
    /**
     * 使用者註冊，儲存
     * @param user
     */
    void save(User user);

    /**
     * 根據使用者名稱查詢使用者
     * @param username
     * @return
     */
    User findByUsername(String username);
}

mapper檔案修改：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.csdn.springboot_shiro_jsp.moudles.user.login.dao.UserDao">
    <!--儲存使用者資訊-->
    <insert id="save" useGeneratedKeys="true" keyProperty="id" parameterType="com.csdn.springboot_shiro_jsp.moudles.user.login.pojo.User">
        insert into t_user values(#{id},#{username},#{password},#{salt})
    </insert>
    <!--根據使用者名稱查詢使用者-->
    <select id="findByUsername" parameterType="string" resultType="com.csdn.springboot_shiro_jsp.moudles.user.login.pojo.User">
        select id,username,password,salt from t_user
        where username=#{username}
    </select>
</mapper>

業務層程式碼：

public interface UserService {
    /**
     * 使用者註冊儲存資訊
     * @param user
     */
    void save(User user);

    /**
     * 根據使用者名稱查詢使用者
     * @param username
     * @return
     */
    User findByUsername(String username);
}

業務層實現類

@Service("userService")
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    /**
     * 使用者註冊儲存使用者資訊
     * @param user
     */
    @Override
    public void save(User user) {
        //獲取隨機鹽
        String salt = new SaltUtils().getSalt(8);
        //拿到使用者輸入的明文密碼
        String password = user.getPassword();
        //新建一個md5Hash的物件傳參
        Md5Hash md5Hash = new Md5Hash(password,salt,1024);
        //s 即為處理後的密碼
        String s = md5Hash.toHex();
        //儲存
        user.setPassword(s);
        user.setSalt(salt);
        userDao.save(user);
    }

    /**
     * 根據使用者名稱查詢使用者
     * @param username
     * @return
     */
    @Override
    public User findByUsername(String username) {
        User user = userDao.findByUsername(username);
        return user;
    }
}

根據之前我們的已經瞭解過得shiro的匹配規則此時，我們還需要去自定義Realm中去修改，從資料庫中獲取使用者資訊，所以我們這時要去自定義Realm去修改。

而此時因為我們的使用者資訊是通過資料庫獲取的，自定義的Realm又不在工廠中被Spring管理所以此時我們需要一個工具類即為通過類名來獲取工廠中的物件。


/**
 * 根據bean名字獲取工廠中指定的bean物件
 */
@Component
public class ApplicationContextUtils implements ApplicationContextAware {
    private static ApplicationContext context;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.context=applicationContext;
    }

    public static Object getBean(String beanName){
        Object bean = context.getBean(beanName);
        return bean;
    }
}

之前我們通過@Service標籤中宣告了一個名字為userService，這樣就可以通過物件名字獲取工廠中的物件。

之後修改自定義Realm：

/*
 * 自定義Realm
 */
public class MyRealm extends AuthorizingRealm {
    /**
     * 授權
     * @param principalCollection
     * @return
     */
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
        return null;
    }

    /**
     * 認證
     * @param authenticationToken
     * @return
     * @throws AuthenticationException
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        String principal = (String) authenticationToken.getPrincipal();
        //在工廠中獲取service物件
        UserService userService = (UserService) ApplicationContextUtils.getBean("userService");
        User user = userService.findByUsername(principal);
        //判斷user不為空時處理
        if (!ObjectUtils.isEmpty(user)){
            SimpleAuthenticationInfo simpleAuthenticationInfo = new SimpleAuthenticationInfo(user.getUsername(),user.getPassword(),
                                                                ByteSource.Util.bytes(user.getSalt()),this.getName());
            return simpleAuthenticationInfo;
        }
        return null;
    }
}

因為我們將密碼加密的策略已經修改為了md5加雜湊所以要將密碼匹配策略修改，修改shiroConfig：

/**
 * 用來整合shiro與springboot的設定類  關係就是一層依賴一層
 */
@Configuration
public class ShiroConfig {

    //建立ShiroFilter過濾器          負責攔截所有請求
    @Bean
    public ShiroFilterFactoryBean shiroFilterFactoryBean(DefaultWebSecurityManager defaultWebSecurityManager){
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        //宣告一個map
        Map<String,String> map = new HashMap<>();
        //設定公共資源
        map.put("/user/**","anon"); //anon:代表這個資源為公共資源
        map.put("/register.jsp","anon");
        //設定系統受限資源
        map.put("/**","authc"); //authc: 代表請求這個資源需要認證和授權
        //將路徑設定給過濾器
        shiroFilterFactoryBean.setFilterChainDefinitionMap(map);
        //預設的登入頁面路徑
        shiroFilterFactoryBean.setLoginUrl("/login.jsp"); //因為shiro與jsp的整合相對友好，所以這個路徑如果不寫也會預設去找，但也可以改變


        //給過濾器設定安全管理器
        shiroFilterFactoryBean.setSecurityManager(defaultWebSecurityManager);
        return shiroFilterFactoryBean;
    }

    //建立安全管理器
    @Bean
    public DefaultWebSecurityManager defaultWebSecurityManager(Realm realm){
        DefaultWebSecurityManager defaultWebSecurityManager = new DefaultWebSecurityManager(realm);
        //給安全管理器設定realm
        defaultWebSecurityManager.setRealm(realm);
        return defaultWebSecurityManager;
    }

    //建立自定義Realm
    @Bean
    public Realm realm(){
        MyRealm myRealm = new MyRealm();
        //修改密碼憑證匹配器  修改匹配策略
        HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
        //密碼加密方式
        hashedCredentialsMatcher.setHashAlgorithmName("md5");
        //設定雜湊次數
        hashedCredentialsMatcher.setHashIterations(1024);
        myRealm.setCredentialsMatcher(hashedCredentialsMatcher);
        return myRealm;
    }
}

全部修改完成之後，啟動專案再來存取一下頁面：

成功！

那麼springboot整合shiro連線資料庫的簡單實現就寫到這裡，後續的文章會繼續加上從資料庫獲取授權資訊的簡單實現，希望大家共同學習一起成長。