基于SSM框架的博客系统博主登录功能

Posted 2020-10-26 Neyazl

一、        准备

1.数据库

创建表db_blogger:

 1 DROP TABLE IF EXISTS `t_blogger`;
 2 
 3 CREATE TABLE `t_blogger` (
 4 
 5   `id` INT(11) NOT NULL AUTO_INCREMENT,
 6 
 7   `userName` VARCHAR(50) DEFAULT NULL,
 8 
 9   `password` VARCHAR(100) DEFAULT NULL,
10 
11   `profile` TEXT,
12 
13   `nickName` VARCHAR(50) DEFAULT NULL,
14 
15   `sign` VARCHAR(100) DEFAULT NULL,
16 
17   `imageName` VARCHAR(100) DEFAULT NULL,
18 
19   `salt` VARCHAR(100) DEFAULT NULL,
20 
21   PRIMARY KEY (`id`)
22 
23 ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
24 
25 INSERT  INTO `t_blogger`(`id`,`userName`,`password`,`profile`,`nickName`,`sign`,`imageName`,`salt`) VALUES (1,‘neya‘,‘7f50069012f25a74bb2783a2d7100f0e‘,NULL,NULL,NULL,NULL,‘Neya‘);

 

2.添加shiro支持

 1 <!-- 添加shiro支持 -->
 2 
 3      <dependency>
 4 
 5           <groupId>org.apache.shiro</groupId>
 6 
 7           <artifactId>shiro-core</artifactId>
 8 
 9           <version>1.2.4</version>
10 
11      </dependency>
12 
13     
14 
15      <dependency>
16 
17           <groupId>org.apache.shiro</groupId>
18 
19           <artifactId>shiro-web</artifactId>
20 
21           <version>1.2.4</version>
22 
23      </dependency>
24 
25     
26 
27      <dependency>
28 
29           <groupId>org.apache.shiro</groupId>
30 
31           <artifactId>shiro-spring</artifactId>
32 
33           <version>1.2.4</version>
34 
35      </dependency>

 

二、        登录界面及登录控制

1.     登录界面

在webapp文件夹下创建login.jsp，以上所需文件及图片可由以下链接下载：链接：https://pan.baidu.com/s/1bqCGJld 密码：701g

 

登录界面如下：

           

2.     创建Realm并配置shiro

Shiro是一个Java平台的开源权限框架，用于认证和访问授权。具体来说，满足对如下元素的支持：

1）用户，角色，权限（仅仅是操作权限，数据权限必须与业务需求紧密结合），资源（url）。

2）用户分配角色，角色定义权限。

3）访问授权时支持角色或者权限，并且支持多级的权限定义。

关于shiro更详细的信息，推荐阅读博客：http://jinnianshilongnian.iteye.com/blog/2018398，暂时可以只阅读前几章，足够本项目使用。

       下面简单说一下本项目中所用到的shiro执行流程：前端从login.jsp获取到用户提交的用户名及密码的表单数据提交到后台的controller处理，在controller相应的登录功能模块中将用户名和密码封装到一个token中（UsernamePasswordToken对象）。在shiro中，应用代码直接交互的对象是Subject，也就是说shiro的对外API核心就是Subject，其代表了当前“用户”，这个用户不一定是具体的人，也可以是与当前应用交互的任何东西。Subject会绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager。在controller中，通过一个Subject实例通过login方法将之前创建的token提交，后续会运行到自定义的MyRealm类，在此类中由方法doGetAuthenticationInfo实现具体的验证逻辑，首先需要根据提交的用户名到数据库中进行查询，得到数据库中相应的密码及盐，然后将用户名、密码、盐封装到一个info（SimpleAuthenticationInfo）中，作为方法的返回值返回，接下来的验证由shiro进行处理，主要是对比提交的token和info中的信息，将token中的密码取出与info中取出的盐使用MD5加密（加密算法及次数在shiro配置文件中配置），得到加密后的字符串与info中的密码字符串进行匹配，相同则验证成功，否则抛出异常。

 

创建包com.neya.shiro,并在其中创建MyRealm类：

 1 public class MyRealm extends AuthorizingRealm{
 2 
 3  
 4 
 5      @Override
 6 
 7      protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
 8 
 9  
10 
11           return null;
12 
13      }
14 
15  
16 
17      @Override
18 
19      protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
20 
21           // TODO Auto-generated method stub
22 
23          
24 
25           return null;
26 
27      }
28 
29     
30 
31       public String getName(){
32 
33            return "myRealm";
34 
35       }
36 
37  
38 
39 }

 

 

在resource中创建shiro 配置文件：applicationContext-shiro:

  1 <?xml version="1.0" encoding="UTF-8"?>
  2 
  3 <beans xmlns="http://www.springframework.org/schema/beans"
  4 
  5      xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  6 
  7      xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
  8 
  9      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 10 
 11      xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 12 
 13      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
 14 
 15      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
 16 
 17      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
 18 
 19      http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">
 20 
 21  
 22 
 23  
 24 
 25  
 26 
 27     <!--securityManage-->
 28 
 29     <!-- 安全管理器 -->
 30 
 31      <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
 32 
 33         <property name="realm" ref="customRealm" />
 34 
 35     </bean>
 36 
 37  
 38 
 39  
 40 
 41      <bean id="lifecycleBeanPostProcessor" class="org.apache.shiro.spring.LifecycleBeanPostProcessor"/>
 42 
 43     
 44 
 45     <bean id="customRealm" class="com.ssm.shiro.MyRealm">
 46 
 47    
 48 
 49     <property name="credentialsMatcher">
 50 
 51                <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
 52 
 53                     <!-- 加密方式 -->
 54 
 55                     <property name="hashAlgorithmName" value="MD5" />
 56 
 57                     <!-- 加密次数 -->
 58 
 59                     <property name="hashIterations" value="1"/>
 60 
 61                </bean>
 62 
 63           </property>
 64 
 65     </bean>
 66 
 67  
 68 
 69      <bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" depends-on="lifecycleBeanPostProcessor"/>
 70 
 71     <bean class="org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor">
 72 
 73     <property name="securityManager" ref="securityManager"/>
 74 
 75 </bean>
 76 
 77  
 78 
 79  
 80 
 81 <!--web.xml中shiro的filter对应的bean-->
 82 
 83     <!-- Shiro 的Web过滤器 -->
 84 
 85     <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
 86 
 87        <property name="securityManager" ref="securityManager" />  
 88 
 89  <!--        loginUrl认证提交地址，如果没有认证将会请求此地址进行认证，请求此地址将由formAuthenticationFilter进行表单认证 -->
 90 
 91         <property name="loginUrl" value="/blogger/login.do" />
 92 
 93      <!--   认证成功统一跳转到first.do，建议不配置，不配置的话shiro认证成功会自动到上一个请求路径 -->
 94 
 95         <property name="filterChainDefinitions">
 96 
 97             <value>
 98 
 99               
100 
101                 /login=anon
102 
103                     /admin/**=authc
104 
105                    
106 
107                     <!-- -/**=authc 表示所有的url都必须认证通过才可以访问- -->
108 
109               
110 
111                 <!--/**=anon 表示所有的url都可以匿名访问，anon是shiro中一个过滤器的简写，关于shiro中的过滤器介绍见-->
112 
113  
114 
115             </value>
116 
117         </property>
118 
119     </bean>
120 
121  
122 
123 </beans>

 

3.     登录控制

使用上一篇中的逆向工程文件generatorConfig.xml将表t_blogger生成相应的实体类及mapper文件，创建相应的Service及实现类：

BloggerService.java：

1 package com.neya.service;
2 
3 import com.neya.domain.Blogger;
4 
5 public interface BloggerService {
6 
7      public Blogger getBloggerByName(String username);
8 
9 }

 

 

BloggerServiceImpl.java：

 1 package com.neya.service.impl;
 2 
 3 import org.springframework.beans.factory.annotation.Autowired;
 4 
 5 import org.springframework.stereotype.Service;
 6 
 7 import com.neya.domain.Blogger;
 8 
 9 import com.neya.mapper.BloggerMapper;
10 
11 import com.neya.service.BloggerService;
12 
13  
14 
15 @Service
16 
17 public class BloggerServiceImp implements BloggerService {
18 
19  
20 
21      @Autowired
22 
23      private BloggerMapper bloggerMapper;
24 
25     
26 
27      @Override
28 
29      public Blogger getBloggerByName(String username) {
30 
31           // TODO Auto-generated method stub
32 
33           Blogger blogger=bloggerMapper.getByUserName(username);
34 
35           return blogger;
36 
37      }
38 
39 }

 

由于逆向工程自动创建的mapper中没有getByUserName方法，所以需要在BloggerMapper.java中添加此方法并在BloggerMapper.xml中实现：

1 <select id="getByUserName" parameterType="String" resultMap="ResultMapWithBLOBs">
2 
3           select * from t_blogger where userName=#{userName}
4 
5 </select>

 

在MyRealm的doGetAuthenticationInfo方法中添加如下代码：

 1 String username=(String) token.getPrincipal();
 2 
 3           Blogger blogger=bloggerService.getBloggerByName(username);
 4 
 5           if(blogger!=null){//能查询到数据则将查询到的数据封装到info中与token比较
 6 
 7                SecurityUtils.getSubject().getSession().setAttribute("currentUser", blogger);
 8 
 9                ByteSource credentialsSalt = ByteSource.Util.bytes(blogger.getSalt());
10 
11                AuthenticationInfo info=new SimpleAuthenticationInfo(blogger.getUsername(), blogger.getPassword(),credentialsSalt,getName());
12 
13                return info;
14 
15           }else{
16 
17                return null;
18 
19           }

 

前面的login.jsp中，表单提交的地址为"${pageContext.request.contextPath}/blogger/login.do"，所以在controller包中创建相应的BloggerController类并使用@RequestMapping注解映射：

package com.neya.controller;

 

import javax.servlet.http.HttpServletRequest;

 

import org.apache.shiro.SecurityUtils;

import org.apache.shiro.authc.UsernamePasswordToken;

import org.apache.shiro.subject.Subject;

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

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

 

import com.neya.domain.Blogger;

import com.neya.service.BloggerService;

 

@Controller

@RequestMapping("/blogger")

public class BloggerController {

    

     @Autowired

     private BloggerService bloggerService;

    

     @RequestMapping("/login")

     public String login(Blogger blogger,HttpServletRequest request){//参数使用spring的自动绑定，从blogger中寻找相应的字段与前端提交的表单的‘name‘匹配，相同则会对blogger的属性直接赋值，比如表单中提交了两项，name属性分别为username和password，则在blogger中，若发现有这两个字段，则直接将提交的数据对这两个字段赋值

          Subject subject=SecurityUtils.getSubject();

          UsernamePasswordToken token=new UsernamePasswordToken(blogger.getUsername(),blogger.getPassword());//根据前端提交的信息创建token

          try{

               subject.login(token);//登录，这里会执行到MyRealm中的代码

               return "redirect:/admin/main.jsp";//登录成功则跳转到相应的后台管理界面

          }catch(Exception e){//验证失败会抛出异常，将失败信息写回前端

               e.printStackTrace();

               request.setAttribute("blogger", blogger);

               request.setAttribute("errorInfo", "用户名或密码错误");

               return "login";

          }

     }

}

 

main.jsp及其所需要的文件在以下链接中：

链接：https://pan.baidu.com/s/1jJ9K8rO 密码：l65t

main.jsp放在webapp下的admin文件夹中

另外，在web.xml中还需要加入shiro过滤器

  

 1  <!--在这里配置shiro的filter-->
 2 
 3    <!-- shiro过虑器，DelegatingFilterProxy通过代理模式将spring容器中的bean和filter关联起来 -->
 4 
 5     <filter>
 6 
 7        <filter-name>shiroFilter</filter-name>
 8 
 9        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
10 
11    <!--     设置true由servlet容器控制filter的生命周期 -->
12 
13        <init-param>
14 
15            <param-name>targetFilterLifecycle</param-name>
16 
17            <param-value>true</param-value>
18 
19        </init-param>
20 
21      <!--   设置spring容器filter的bean id，如果不设置则找与filter-name一致的bean -->
22 
23        <init-param>
24 
25            <param-name>targetBeanName</param-name>
26 
27            <param-value>shiroFilter</param-value>
28 
29        </init-param>
30 
31    </filter>
32 
33    <filter-mapping>
34 
35        <filter-name>shiroFilter</filter-name>
36 
37        <url-pattern>/*</url-pattern>
38 
39    </filter-mapping>

 

接下来启动tomcat，并在浏览器中输入http://localhost:8080/MyBlog/login.jsp，填入用户名neya及密码123456,点击登录即可跳转到相应后台管理界面