前后端分离(session管理)(一)简单实例

已于 2023-12-28 09:56:52 修改
阅读量1.6k 收藏 5
点赞数
分类专栏： Shiro+VUE 文章标签： spring boot 后端 java
于 2020-06-11 15:40:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_t_y_y/article/details/106690283
版权

本例使用了springboot+dubbo+shiro(sessin管理)，dubbo服务部分就不看了

一、代码：

1、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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>shiro-session</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.1.RELEASE</version>
    </parent>

    <dependencies>
        <!--api-->
        <dependency>
            <groupId>com.demo</groupId>
            <artifactId>mysercurity-api</artifactId>
            <version>1.0.0-SNAPSHOT</version>
        </dependency>

        <!-- dubbo -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

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

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <!--httpclient -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.6</version>
        </dependency>

        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper</artifactId>
            <version>5.1.8</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.31</version>
        </dependency>

        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.5</version>
        </dependency>

        <!--zk-->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>log4j</artifactId>
                    <groupId>log4j</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>slf4j-log4j12</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- shiro spring. -->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>1.2.2</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-ehcache</artifactId>
            <version>1.2.2</version>
        </dependency>

    </dependencies>

    <repositories>
        <repository>
            <id>spring-milestones</id>
            <name>Spring Milestones</name>
            <url>https://repo.spring.io/libs-milestone</url>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>


</project>

2、appliation.properties：

server.port=7777
server.context-path=/shirodemo

#配置session过期时间
shiro.session.expireTime=5000

3、ehcache.xml：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <defaultCache
            eternal="false"
            maxElementsInMemory="1000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="600"
            memoryStoreEvictionPolicy="LRU"/>

    <!-- 这里的 auth 缓存 -->
    <cache
            name="auth"
            eternal="false"
            maxElementsInMemory="100"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="0"
            timeToLiveSeconds="300"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>

4、config：shiro总配置类：

package com.shiro.session.config;
import javax.servlet.Filter;
import com.shiro.session.exception.MyExceptionHandler;
import com.shiro.session.realms.MyShiroRealm;
import com.shiro.session.system.MySessionManager;
import com.shiro.session.system.ShiroFormAuthenticationFilter;
import org.apache.shiro.cache.ehcache.EhCacheManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.session.mgt.SessionManager;
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.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.web.servlet.HandlerExceptionResolver;
import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class ShiroConfig {

    @Autowired
    private CacheManager cacheManager;

    @Bean
    public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager((org.apache.shiro.mgt.SecurityManager) securityManager);
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        //注意过滤器配置顺序
        //配置退出过滤器,其中的具体的退出代码Shiro已经替我们实现了，登出后跳转配置的loginUrl,
        // authc:所有url都必须认证通过才可以访问; anon:所有url都都可以匿名访问
        filterChainDefinitionMap.put("/static/**", "anon");
        filterChainDefinitionMap.put("/code/getCode", "anon");
        filterChainDefinitionMap.put("/user/login", "anon");
        //剩下接口全部需要认证
        filterChainDefinitionMap.put("/**", "authc");
        // 配置shiro默认登录界面地址，前后端分离中登录界面跳转应由前端路由控制，后台仅返回json数据
        shiroFilterFactoryBean.setLoginUrl("/home/unauth");
        LinkedHashMap<String, Filter> filtsMap=new LinkedHashMap<String, Filter>();
        filtsMap.put("authc",new ShiroFormAuthenticationFilter() );
        shiroFilterFactoryBean.setFilters(filtsMap);
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }

    @Bean
    public MyShiroRealm myShiroRealm() {
        MyShiroRealm realm = new MyShiroRealm();
        realm.setCacheManager(getEhCacheManager());
        return realm;
    }

    @Bean
    public EhCacheManager getEhCacheManager(){
        EhCacheManager ehcacheManager = new EhCacheManager();
        ehcacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
        return ehcacheManager;
    }

    @Bean
    public SecurityManager securityManager() {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(myShiroRealm());
        securityManager.setSessionManager(sessionManager());
        securityManager.setCacheManager(getEhCacheManager());
        return securityManager;
    }

    /**
     * 自定义sessionManager
     */
    @Bean
    public SessionManager sessionManager() {
        return new MySessionManager();
    }

    /**
     * 开启shiro aop注解支持
     * @return
     */
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor() {
        System.out.println("开启shiro注解");
        AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
        authorizationAttributeSourceAdvisor.setSecurityManager(securityManager());
        return authorizationAttributeSourceAdvisor;
    }

    @Bean
    public LifecycleBeanPostProcessor lifecycleBeanPostProcessor(){
        return new LifecycleBeanPostProcessor();
    }
    /**
     * 自动创建代理
     * @return
     */
    @Bean
    @DependsOn({"lifecycleBeanPostProcessor"})
    public DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator advisorAutoProxyCreator = new DefaultAdvisorAutoProxyCreator();
        advisorAutoProxyCreator.setProxyTargetClass(true);
        return advisorAutoProxyCreator;
    }
    /**
     * 注册全局异常处理
     * @return
     */
    @Bean(name = "exceptionHandler")
    public HandlerExceptionResolver handlerExceptionResolver() {
        return new MyExceptionHandler();
    }
}

5、realms：shiro登录认证，登录接口subject.login(usernamePasswordToken)调用的方法：

package com.shiro.session.realms;
import com.demo.dto.AuthorityDTO;
import com.demo.dto.UserDTO;
import com.demo.service.UserService;
import com.shiro.session.util.MD5Util;
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.springframework.beans.factory.annotation.Autowired;
import java.security.NoSuchAlgorithmException;
import java.util.List;


public class MyShiroRealm extends AuthorizingRealm {


    @Autowired
    private UserService userService;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
        UserDTO userInfo = (UserDTO) principals.getPrimaryPrincipal();
        List<AuthorityDTO> authorities = userService.getAuthortiesByUserId(userInfo.getId());
        // 添加权限
        for (AuthorityDTO authority : authorities) {
            if (authority != null){
                authorizationInfo.addStringPermission(authority.getAuthorityName());
            }

        }
        // 添加角色
        return authorizationInfo;
    }

    /**
     *
     * 用来进行身份认证的，也就是说验证用户输入的账号和密码是否正确
     *
     */
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token)
            throws AuthenticationException {
        // 获取用户的输入的域账号
        UsernamePasswordToken currentUser = (UsernamePasswordToken) token;
        String userAccount = currentUser.getUsername();
        // 明文密码
        String password = String.valueOf(currentUser.getPassword());
        //加密后的密码
        String md5Password = null;
        UserDTO user = userService.findByUserName(userAccount);
        if(user == null){
            throw new IncorrectCredentialsException();
        }
        try {
            md5Password = MD5Util.MD5(password);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        if(!user.getPassword().equals(md5Password)){
            throw new IncorrectCredentialsException();
        }
        return new SimpleAuthenticationInfo(user, password, getName());
    }

}

6、其他系统配置：

（1）MySessionManager：获取sessionId：

package com.shiro.session.system;

import org.apache.shiro.web.servlet.ShiroHttpServletRequest;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.apache.shiro.web.util.WebUtils;
import org.springframework.util.StringUtils;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.Serializable;

public class MySessionManager extends DefaultWebSessionManager {
    private static final String AUTHORIZATION = "X-Token";

    private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";

    public MySessionManager() {
        super();
    }

    @Override
    protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
        String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
        // 如果请求头中有 AUTHORIZATION 则其值为sessionId
        if (!StringUtils.isEmpty(id)) {
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            return id;
        } else {
            //否则按默认规则从cookie取sessionId
            return super.getSessionId(request, response);
        }
    }
}

（2）ShiroFormAuthenticationFilter：对于ShiroConfig中配置authc的接口做拦截认证，当token不匹配时候会走到这里：

package com.shiro.session.system;

import com.alibaba.fastjson.JSON;
import com.shiro.session.dto.CommonEnums;
import com.shiro.session.dto.ResponseMessage;
import org.apache.shiro.web.filter.authc.FormAuthenticationFilter;
import org.springframework.web.bind.annotation.RequestMethod;
import com.alibaba.fastjson.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpStatus;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;

public class ShiroFormAuthenticationFilter extends FormAuthenticationFilter{
    Logger logger  = LoggerFactory.getLogger(ShiroFormAuthenticationFilter.class);

    @Override
        protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception {
        String requestURI = this.getPathWithinApplication(request);
        if (isLoginRequest(request, response) || requestURI.equals("/sse/getData")) {
            if (isLoginSubmission(request, response)) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Login submission detected.  Attempting to execute login.");
                }
                return executeLogin(request, response);
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Login page view.");
                }
                //allow them to see the login page ;)
                return true;
            }
        } else {
            HttpServletRequest req = (HttpServletRequest)request;
            HttpServletResponse resp = (HttpServletResponse) response;
            if(req.getMethod().equals(RequestMethod.OPTIONS.name())) {
                resp.setStatus(HttpStatus.OK.value());
                return true;
            }

            if (logger.isTraceEnabled()) {
                logger.trace("Attempting to access a path which requires authentication.  Forwarding to the " +
                        "Authentication url [" + getLoginUrl() + "]");
            }
            resp.setHeader("Access-Control-Allow-Origin",  req.getHeader("Origin"));
            resp.setHeader("Access-Control-Allow-Credentials", "true");
            resp.setContentType("application/json; charset=utf-8");
            resp.setCharacterEncoding("UTF-8");
            PrintWriter out = resp.getWriter();
            ResponseMessage result = new ResponseMessage(CommonEnums.CODE_500.code,"error","登录失效");
            out.println(JSON.toJSONString(result));
            out.println(JSON.toJSONString(result));
            out.flush();
            out.close();
            return false;
        }
    }
}

7、handler：

package com.shiro.session.handler;

import com.alibaba.fastjson.support.spring.FastJsonJsonView;
import com.shiro.session.dto.CommonEnums;
import org.apache.shiro.authz.UnauthorizedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.Map;


public class MyExceptionHandler implements HandlerExceptionResolver {

    private static Logger log = LoggerFactory.getLogger(MyExceptionHandler.class);

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView mv = new ModelAndView();
        FastJsonJsonView view = new FastJsonJsonView();
        Map<String, Object> attributes = new HashMap<String, Object>();
        if(e instanceof UnauthorizedException){
            attributes.put("code", CommonEnums.CODE_500.code);
            attributes.put("msg", "权限不够");
        }else{
            attributes.put("code", CommonEnums.CODE_500.code);
            attributes.put("msg", "系统异常，请反馈管理员");
        }
        view.setAttributesMap(attributes);
        mv.setView(view);
        log.error("异常:" + e.getMessage(), e);
        return mv;
    }
}

8、utils：

（1）md5加密util：

package com.shiro.session.util;

import org.apache.commons.codec.digest.DigestUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
public class MD5Util {

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

    private final static String APP_KEY="hYHN#1son@16faEV2";
    private final static String CHARSET="UTF-8";
    /**
     * MD5加密算法
     *
     * @param s
     * @return
     */
    public final static String MD5(String s) throws NoSuchAlgorithmException {
        char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                'A', 'B', 'C', 'D', 'E', 'F' };
        byte[] btInput = s.getBytes();
        // 获得MD5摘要算法的 MessageDigest 对象
        MessageDigest mdInst;
        mdInst = MessageDigest.getInstance("MD5");
        // 使用指定的字节更新摘要
        mdInst.update(btInput);
        // 获得密文
        byte[] md = mdInst.digest();
        // 把密文转换成十六进制的字符串形式
        int j = md.length;
        char str[] = new char[j * 2];
        int k = 0;
        for (int i = 0; i < j; i++) {
            byte byte0 = md[i];
            str[k++] = hexDigits[byte0 >>> 4 & 0xf];
            str[k++] = hexDigits[byte0 & 0xf];
        }
        return new String(str);
    }


    /**
     * 编码转换
     * @param content
     * @param charset
     * @return
     * @throws UnsupportedEncodingException
     */
    private static byte[] getContentBytes(String content, String charset) {
        if (charset == null || "".equals(charset)) {
            return content.getBytes();
        }
        try {
            return content.getBytes(charset);
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,您目前指定的编码集是:" + charset);
        }
    }

    public static String sign(String prestr){
        String mysign = DigestUtils.md5Hex(getContentBytes(prestr + APP_KEY, CHARSET));
        return mysign;
    }

    public static String signParams(Map<String,String> params){
        try {
            if (params != null && params.size()>0){
                List<Map.Entry<String, String>> list = new ArrayList(params.entrySet());
                Collections.sort(list, new Comparator<Map.Entry<String,String>>() {
                    @Override
                    public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
                        return o1.getKey().compareTo(o2.getKey());
                    }
                });
                StringBuffer sb = new StringBuffer();
                for (Map.Entry<String, String> ent:list) {
                    sb.append(ent.getKey());
                    sb.append(ent.getValue());
                }
                logger.info("原字符串：{}",sb.toString());
                return sign(sb.toString());
            }
        }catch (Exception e){

        }
        return "";
    }

    public static boolean isSign(HashMap<String,String> params,String sign){
        try{
            String newSign = signParams(params);
            logger.info("原签名：{}",sign);
            logger.info("新签名：{}",newSign);
            if (Objects.equals(sign,newSign)){
                return true;
            }
        }catch (Exception e){

        }
        return false;
    }



}

package com.shiro.session.util;


import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

public class AESUtils {

    private static String iv = "HGty&6%4ojyUyhgy";//偏移量字符串必须是16位 当模式是CBC的时候必须设置偏移量
    private static String Algorithm = "AES";
    private static String AlgorithmProvider = "AES/CBC/PKCS5Padding"; //算法/模式/补码方式
    public final static String key="FUjs@17654HGJKKn";

    public static byte[] generatorKey() throws NoSuchAlgorithmException {
        KeyGenerator keyGenerator = KeyGenerator.getInstance(Algorithm);
        keyGenerator.init(256);//默认128，获得无政策权限后可为192或256
        SecretKey secretKey = keyGenerator.generateKey();
        return secretKey.getEncoded();
    }

    public static IvParameterSpec getIv() throws UnsupportedEncodingException {
        IvParameterSpec ivParameterSpec = new IvParameterSpec(iv.getBytes("utf-8"));
        System.out.println("偏移量："+byteToHexString(ivParameterSpec.getIV()));
        return ivParameterSpec;
    }

    public static byte[] encrypt(String src, byte[] key) throws NoSuchAlgorithmException, NoSuchPaddingException,
            InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);
        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
        byte[] cipherBytes = cipher.doFinal(src.getBytes(Charset.forName("utf-8")));
        return cipherBytes;
    }

    public static byte[] decrypt(String src, byte[] key) throws Exception {
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);

        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
        byte[] hexBytes = hexStringToBytes(src);
        byte[] plainBytes = cipher.doFinal(hexBytes);
        return plainBytes;
    }

    /**
     * 解密
     * @param src
     * @param keyStr
     * @return
     * @throws Exception
     */
    public static String decryptStr(String src, String keyStr) throws Exception {

        byte key[] = keyStr.getBytes("utf-8");
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);

        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
        byte[] hexBytes = hexStringToBytes(src);
        byte[] plainBytes = cipher.doFinal(hexBytes);
        return new String(plainBytes,"UTF-8");
    }


    public static String encrypt(String src, String keyStr) throws NoSuchAlgorithmException, NoSuchPaddingException,
            InvalidKeyException, IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException, InvalidAlgorithmParameterException {

        byte key[] = keyStr.getBytes("utf-8");
        SecretKey secretKey = new SecretKeySpec(key, Algorithm);
        IvParameterSpec ivParameterSpec = getIv();
        Cipher cipher = Cipher.getInstance(AlgorithmProvider);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
        byte[] cipherBytes = cipher.doFinal(src.getBytes(Charset.forName("utf-8")));
        return new String(cipherBytes,"UTF-8");
    }

    public static void main(String args[]){
        try {
            String passwordMd5 = MD5Util.MD5("123456");
            System.out.println("加密后密码："+passwordMd5);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 将byte转换为16进制字符串
     * @param src
     * @return
     */
    public static String byteToHexString(byte[] src) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xff;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                sb.append("0");
            }
            sb.append(hv);
        }
        return sb.toString();
    }

    /**
     * 将16进制字符串装换为byte数组
     * @param hexString
     * @return
     */
    public static byte[] hexStringToBytes(String hexString) {
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] b = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            b[i] = (byte) (charToByte(hexChars[pos]) << 4 | (charToByte(hexChars[pos + 1]))& 0xff);
        }
        return b;
    }

    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }


     /*public static void main(String[] args) {
        try {
            // byte key[] = generatorKey();
            System.out.println("FUjs@17654HGJKKn".length());
            // 密钥必须是16的倍数
            byte key[] = "FUjs@17654HGJKKn".getBytes("utf-8");//hexStringToBytes("0123456789ABCDEF");
            String src = "usersrs=111111?sdfjsalkj=1mlkjklasjdfkls?sss=sdfsjlk1123123123?sdd=453456465432165765432221351567897654132";
            System.out.println("密钥:"+byteToHexString(key));
            System.out.println("原字符串:"+src);

            String enc = byteToHexString(encrypt(src, key));
            System.out.println("加密："+enc);
            System.out.println("解密："+decryptStr(enc, AESUtils.key));
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }*/


}

（2）session获取用户util：

package com.shiro.session.util;

import com.demo.dto.UserDTO;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

public class SessionContext {
    public static String getCurrentUser(){
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (servletRequestAttributes == null) {
            return null;
        }
        HttpServletRequest httpServletRequest = servletRequestAttributes.getRequest();
        return (String) httpServletRequest.getSession().getAttribute("currentUser");
    }
}

9、启动类：

package com.shiro.session;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

@SpringBootApplication
@ImportResource("classpath:consumer.xml")
public class Application {
    public static void main(String args[]){
        SpringApplication.run(Application.class,args);
    }
}

二、测试：

1、使用postman模拟浏览器：

（1）访问获取分页接口，可以看到未登录情况下请求被拒绝了：

（2）访问获取验证码接口，获取成功：

证明ShiroConfig中配置的过滤链生效；

（3）登录：

（4）再次获取分页用户接口，调用成功：

（5）退出登录：

（6）再次访问获取分页用户接口，失败：

身份验证成功

2、此时，再在浏览器中验证下

（1）访问获取所有用户（get请求）接口，由于该浏览器与服务器的session会话未建立登录成功，调用接口失败：

（2）登录一下：

（3）再次 访问之前的接口，访问成功：

w_t_y_y
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
前后端分离 | 关于登录状态那些事
weixin_34270865的博客
10-12 1348
背景 登录是一个网站最基础的功能。有人说它很简单，其实不然，登录逻辑很简单，但涉及知识点比较多，如：密码加密、cookie、session、token、JWT等。 我们看一下传统的做法，前后端统一在一个服务中： 如图所示，逻辑处理和页面放在一个服务中，用户输入用户名、密码后，后台服务在session中设置登录状态，和用户的一些基本信息，然后将响应（Re...
基于SpringBoot2+Jpa+SpringSecurity+redis+Vue的前后端分离系统
03-10
系统功能模块 用户管理 提供用户的相关配置 角色管理 角色菜单分配权限 权限管理 权限细化到接口 菜单管理 已实现动态路由，后端可配置化 系统日志 记录用户访问监控异常信息 系统缓存管理 将redis的操作可视化，提供对redis的基本操作 Sql监控 采用 druid 监控数据库访问性能 技术栈 基础框架：Spring Boot 2.1.0.RELEASE 持久层框架：Spring boot Jpa 安全框架：Spring Security 缓存框架：Redis 日志打印：logback+log4jdbc 接口文档 swagger2 其他：fastjson，aop，MapStruct等。 页面框架：Vue 前端源码：eladmin-qt 后端源码：eladmin
spring+shiro共享session完整小例子
weixin_34326179的博客
06-26 324
之前写过一个，只不过那个不单纯，有人跑不通，所以今天整个纯粹的小例子。 要求你有Redis。 源码 GitHub 目录结构 因为这是个例子，仅仅为了体现共享session，所以权限认证部分没有加入处理逻辑。目录结构也做了简化。 打包好，为下一步做准备 配置Tomcat 准备两个Tomcat，先修改配置文件。 Tomcat-1 Tomcat...
springboot集成shiros自定义md5加密自定义token认证
最新发布
a360284634的博客
06-18 831
spring boot 集成 shiro，shiro介绍，shiro与springSecurity区别，shiro优缺点
shiro（session+redis），基于springboot，基于前后端分离，从登录认证到鉴权
weixin_43973712的博客
11-13 4057
这个demo是基于springboot项目的。 名词介绍： Shiro 主要分为 安全认证 和 接口授权 两个部分，其中的核心组件为 Subject、 SecurityManager、 Realms，公共部分 Shiro 都已经为我们封装好了，我们只需要按照一定的规则去编写响应的代码即可… Subject 表示主体，将用户的概念理解为当前操作的主体，因为它即可以是一个通过浏览器请求的用户，也可能是一个运行的程序，外部应用与 Subject 进行交互，记录当前操作用户。Subject 代表了当前用户的安全操作
前后端分离项目，使用session作为用户状态记录
qq_35530330的博客
12-20 6702
在使用前后端分离的项目中，我们一般选择无状态的请求方式，即web token；或者搭建缓存服务器，来准们存储用户的登录状态。一般不会使用servlet的session来存储用户状态，因为这种方式不太安全，而且前后端分离的项目中每次访问的时候，所携带的sessionId也是不相同的，所以是无法使用session的。 虽然session没有其他的实现方式安全，但是我们能不能使用session存储tok...
springboot+vue 的前后端分离可以使用session 的案例
weixin_35756373的博客
02-16 1430
Spring Boot和Vue的前后端分离架构下，可以使用session进行用户会话管理。具体案例如下： 在后端Spring Boot应用中，使用Spring Session框架来管理session。Spring Session支持多种session存储方式，如Redis、MongoDB等，可以根据具体情况选择适合的存储方式。 在前端Vue应用中，可以使用axios等HTTP库发送请求到后端，...
后台管理系统，前后端分离，后端SpringBoot+Shiro+MyBatis+Redis，前端Vue+Elemen.zip
02-22
这是一个基于现代技术栈的后台管理系统实现，采用了前后端分离的架构模式。让我们深入探讨这个系统背后的各个技术组件及其重要性。 首先，后端的核心框架是SpringBoot，它是由Pivotal团队开发的Java轻量级框架，...
基于java+Servlet实现的前后端分离编写的机票预订管理系统.zip
08-16
本系统“基于Java+Servlet实现的前后端分离编写的机票预订管理系统”便是这种模式的一个典型实例，下面我们将详细探讨其核心知识点。 1. **Java与Servlet技术** Java是一种广泛使用的编程语言，尤其在服务器端开发...
flask框架下的前后端分离的房屋租住项目.zip
09-28
在IT行业中，前后端分离是一种常见的开发模式，它将应用程序分为两个主要部分：前端和后端，以便于各自的专业化开发和维护。本项目“flask框架下的前后端分离的房屋租住项目”是一个很好的实践案例，展示了如何利用...
微信小程序 http请求的session管理
08-30
这个问题也存在于前后端分离开发中，前端程序员请求的每个接口程序也是都会改变 Session ID 的，无法获取到登录时保存在 Session 中的用户信息。 常见的 Session 保持方式 常见的 Session 保持方式是，当浏览器向...
基于Django框架，使用Django REST framework前后端分离技术搭建的网上图书商店.zip
04-26
【描述】：这个项目是一个采用Python的Django框架和Django REST framework构建的网上图书商店，实现了完整的前后端分离。它展示了如何在Web开发中有效地处理API接口，以及如何通过RESTful API进行数据交互。 【知识...
Spring boot 前后端分离项目的环境及准备
qq_69635978的博客
07-11 867
主要是对Spring boot中前后端分离项目的前端环境后后端环境进行学习
前后端分离中session问题的处理与设计
小张的博客
04-18 2623
前后端分离项目中session问题的处理，并且使用token进行用户信息的验证和维护
前后端分离常用的认证方式（ Session 、JWT）
cliper9768的博客
01-08 3060
而jwt为了防止泄露，应该将有效期设置的比较短，为了减少盗用， 最好使用HTTPS协议传输，因为HTTP是明码传输的。session-cookie方案 就是利用cookie来管理session，即把 Session 放入 HTTP 响应中还给客户端，并保存在客户端，当客户端发送下一次请求的时候，就把这个 Session 一起发送回来，这样就能这次的请求是谁发出来的了。更像是一种授权机制。token(令牌，访问资源的凭证) 认证是一种机制，具体的实现可以是一个随机的字符串，也可以是标准的jwt。
（十三）springboot实战——springboot前后端分离方式项目集成spring securtity安全框架
厉害哥哥的博客
02-06 1999
Spring Security 是一款强大且高度可定制的认证和访问控制框架，它是为了保护基于Spring的应用程序提供安全性支持。Spring Security 提供了全面的安全服务，主要针对企业级应用程序的需求。其核心组件主要包含：Authentication（认证）、Authorization（授权）、Principal（主体）、Granted Authority（授予的权限）、Security Context（安全上下文），可提供方法级别的权限认证。其底层主要通过Filter拦截器实现，关于其实现原理
前后端分离---前后端身份验证（session和jwt）
前端与计算机相关知识的分享，博主的qq523235674
03-07 8402
一.web开发模式 目前主流的Web开发模式有两种，分别是: ①基于服务端渲染的传统Web开发模式 ②基于前后端分离的新型Web开发模式 1.服务器端渲染的Web开发模式 服务端渲染的概念:服务器发送给客户端的HTML页面，是在服务器通过字符串的拼接，动态生成的。因此，客户端不需要使用Ajax这样的技术额外请求页面的数据。代码示例如下: 2.服务器端渲染的优缺点 ①优点： 前端耗时少。因为服务器端负责动态生成HTML内容，浏览器只需要直接渲染页面即可。尤其是移动端，更省电。 有利于
实现前后端session共享
weixin_54065960的博客
07-11 736
实现前后端session共享问题
springboot-vue前后端分离项目跨域session不一致的问题
shileimohan的专栏
10-14 147
https://blog.csdn.net/oldlimu/article/details/123889850
前后端分离,使用webSocket如何建立连接，给一份java后端实例代码
05-30
好的，下面是一个使用 Java 语言的 WebSocket 后端实例代码，示例使用 Spring Boot 和 Spring WebSocket 框架： 1. 首先，需要在 pom.xml 文件中添加 Spring WebSocket 的依赖： ```xml <groupId>org.spring...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

w_t_y_y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值