Shiro加入到Maven项目

最新推荐文章于 2023-08-02 15:25:46 发布
最新推荐文章于 2023-08-02 15:25:46 发布
阅读量2.7k 收藏 2
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_39120378/article/details/103715593
版权

shiro加入到项目里面

(1)创建一个maven模块

(2)导入shiro的依赖包

​

        <!--shiro的包-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-all</artifactId>
            <version>1.4.1</version>
        </dependency>
        <!--servlet 相关的包-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>4.2.5.RELEASE</version>
        </dependency>

引用:

shiro 模块 -->pom.xml 引入server层

	<dependency>
	        <groupId>cn.dsq</groupId>
	        <artifactId>crm_service</artifactId>
	        <version>1.0-SNAPSHOT</version>
	</dependency>

web 模块 -->pom.xml 引入shiro层

  <dependency>
            <groupId>cn.dsq</groupId>
            <artifactId>crm_shiro</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

(3)在web.xml 配置代理过滤器

<filter>
    <filter-name>shiroFilter</filter-name>
    <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    <init-param>
      <param-name>targetFilterLifecycle</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>

<filter-mapping>
   <filter-name>shiroFilter</filter-name>
   <url-pattern>/*</url-pattern>
 </filter-mapping>

(4)新建一个文件applicationContext-shiro.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

    <!--shiro的核心对象 realm-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <!--配置realm-->
        <property name="realm" ref="authRealm"/>
    </bean>

    <!--Realms-->
    <bean id="authRealm" class="cn.itsource.shiro.realm.AuthenRealm">
        <property name="credentialsMatcher">
            <bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
                <property name="hashAlgorithmName" value="MD5"/>
                <property name="hashIterations" value="10"/>
            </bean>
        </property>
    </bean>

    <!--shiro的过滤器配置 web.xml的代理过滤器名称一样-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/s/login"/>
        <property name="successUrl" value="/s/index"/>
        <property name="unauthorizedUrl" value="/s/unauthorized"/>

        <property name="filterChainDefinitions">
            <value>
                /login = anon
                /** = authc
            </value>
        </property>
    </bean>

</beans>

(5)在web.xml引入shiro的配置文件

<!-- Spring的配置文件 -->
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
        classpath:applicationContext.xml,
        classpath:applicationContext-shiro.xml
    </param-value>
  </context-param>

到这里就基本完成shiro加入到分模块开发的maven项目

登录和登录之后访问数据

用户密码加密

1.员工密码加密保存

1）已有员工测试类加密保存
规定已有员工密码都是1，通过MD5Util工具加密后存放到数据库

public class MD5Util {
	/**盐*/
    public static final String SALT = "dsq";

    /**
     * 加密方法
     * @param source
     * @return
     */
    public static String encrypt(String source){
    	//加密方式-MD5  加密数据-source -  加盐-SALT 加密次数-10
        SimpleHash simpleHash = new SimpleHash("MD5",source,SALT,10);
        return simpleHash.toString();
    }
	//测试法法
    public static void main(String[] args) {
        System.out.println(encrypt("1"));
    }

}

2）没有的员工添加是加密保存
EmployeeController中

@Override
   public AjaxResult addOrUpdate(Employee employee) {
   	//没有id表示是新增
       if (employee.getId()==null){
       	//密码进行加密
           employee.setPassword(MD5Util.encrypt(employee.getPassword()));
           //保存
           employeeService.add(employee);
       }else{
       	//修改
           employeeService.update(employee);
       }
       return AjaxResult.me();
   }

登录实现

1）login.vue

handleSubmit2(ev) {
  var _this = this;
  this.$refs.ruleForm2.validate((valid) => {
    if (valid) {
      this.logining = true;
      var loginParams = { username: this.ruleForm2.account, password: this.ruleForm2.checkPass };
      this.$http.post("/login",loginParams).then(data => {
        this.logining = false;
        let { message, success, resultObj } = data.data;
        if (!success) {
          this.$message({
            message: message,
            type: 'error'
          });
        } else {
          //登录成功跳转/table的路由地址
          sessionStorage.setItem('user', JSON.stringify(resultObj));
          //修改登录成功后跳转到首页
          this.$router.push({ path: '/home' });
        }
      });
    } else {
      console.log('error submit!!');
      return false;
    }
  });
}

2）LoginController

@Controller
@CrossOrigin
public class LoginController {
    /**
     * 身份认证--登录
     * @param employee
     * @return
     */
    @RequestMapping(value = "/login",method = RequestMethod.POST)
    @ResponseBody
    public AjaxResult login(@RequestBody Employee employee){
        Subject currentUser = SecurityUtils.getSubject();
        if(!currentUser.isAuthenticated()){

            try {
                UsernamePasswordToken token = new UsernamePasswordToken(employee.getUsername(),
                        employee.getPassword());
                currentUser.login(token);
            } catch (UnknownAccountException e) {
                e.printStackTrace();
                return AjaxResult.me().setSuccess(false).setMessage("用户名不存在!");
            } catch (IncorrectCredentialsException e){
                e.printStackTrace();
                return AjaxResult.me().setSuccess(false).setMessage("密码错误!");
            } catch (AuthenticationException e){
                e.printStackTrace();
                return AjaxResult.me().setSuccess(false).setMessage("系统异常！");
            }

        }
        Employee employee1 = (Employee) currentUser.getPrincipal();
        employee.setPassword(null);

        //除了返回登录成功与否,还要把登录的用户返回前端
        return AjaxResult.me().setResultObj(employee1);
    }

}

由于前台需要返回用户，所以改造AJaxResult

/**
 * Ajax请求的返回内容:增删改
 *    success:成功与否
 *    message:失败原因
 */
public class AjaxResult {

    private boolean success = true;
    private String message = "操作成功!";
    private Object resultObj = null;

    public boolean isSuccess() {
        return success;
    }

    //链式编程,可以继续. 设置完成后自己对象返回
    public AjaxResult setSuccess(boolean success) {
        this.success = success;
        return this;
    }

    public String getMessage() {
        return message;
    }

    public AjaxResult setMessage(String message) {
        this.message = message;
        return this;
    }

    //默认成功
    public AjaxResult() {
    }

    //失败调用
    public AjaxResult(String message) {
        this.success = false;
        this.message = message;
    }

    public Object getResultObj() {
        return resultObj;
    }

    public AjaxResult setResultObj(Object resulObj) {
        this.resultObj = resultObj;
        return this;
    }

    //不要让我创建太多对象
    public static AjaxResult me(){
        return new AjaxResult();
    }

    public static void main(String[] args) {
        AjaxResult.me().setMessage("xxx").setSuccess(false);
    }
}

3）Realm

/**
 * 自定义身份认证Realm
 */
public class AuthenRealm extends AuthenticatingRealm {

    @Autowired
    private IEmployeeService employeeService;

    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
        UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
        String username = token.getUsername();
        Employee employee = employeeService.getByUsername(username);
        if(employee==null){
            throw new UnknownAccountException(username);
        }
        Object principal = employee;
        Object hashedCredentials = employee.getPassword();
        ByteSource credentialsSalt = ByteSource.Util.bytes(MD5Util.SALT);
        String realmName = getName();
        SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(principal,hashedCredentials,credentialsSalt,realmName);
        return info;
    }

}

4）Service–Saas租户相关的，没有这个可以不管

public interface IEmployeeService extends IBaseService<Employee> {
    /**
     * 添加租户员工
     * @param employee
     */
    void addTenantEmployee(Employee employee);
	/**
	 * 通过username查询用户
	 * @param username
	 */
    Employee getByUsername(String username);
}

--------------------------------------------------------------------

@Service
public class EmployeeServiceImpl extends BaseServiceImpl<Employee> implements IEmployeeService {

    @Autowired
    private TenantMapper tenantMapper;

    @Autowired
    private EmployeeMapper employeeMapper;
    
    @Override
    public void addTenantEmployee(Employee employee) {
    	//获取租户
        Tenant tenant = employee.getTenant();
        //设置租户注册时间
        tenant.setRegisterTime(new Date());
        //租户状态
        tenant.setState(0);
        //添加租户返回租户id   添加前对象里面没有id,添加完成后就有了
        tenantMapper.save(tenant);
        //把租户id设置给员工
        employee.setTenant(tenant);
        //在保存员工
        employee.setRealName(employee.getUsername());
        employeeMapper.save(employee);
    }

    @Override
    public Employee getByUsername(String username) {
        return employeeMapper.loadByUsername(username);
    }
}

5）Mapper

/**
 * 通过继承baseMapper拥有的基础crud,还可以扩展自己方法
 */
public interface EmployeeMapper extends BaseMapper<Employee> {
    Employee loadByUsername(String username);
}

mapper.xml

<!--Employee loadByUsername(String username);-->
	<select id="loadByUsername" parameterType="string" resultType="Employee">
		select * from t_employee WHERE  username = #{username}
	</select>

登录成功之后 无法查询数据。这个什么原因导致的?

cookie的管理机制导致

原因分析

前后端分离项目中，ajax请求没有携带cookie，所以后台无法通过cookie获取到SESSIONID，从而无法获取到session对象。而shiro的认证与授权都是通过session实现的，我们要想办法解决这个问题。
在这里插入图片描述前后端需要建立会话机制
通过token的机制建立前端和后端的会话管理机制
在这里插入图片描述1）登录成功后返回token，并以后每次ajax请求都要携带token
LoginController后台控制器

		Employee employee1 = (Employee) currentUser.getPrincipal();
        employee.setPassword(null);
        Map<String,Object> result = new HashMap<>();
        result.put("user",employee1);
        System.out.println(currentUser.getSession().getId()+"xxxx"); 
        //登录成功后把会话id返回，会后作为token使用
        result.put("token",currentUser.getSession().getId());

        return AjaxResult.me().setResultObj(result);

Longin.vue前端登录页面

 this.$http.post("/login",loginParams).then(data => {
              this.logining = false;
              let { success, message, resultObj } = data.data;
              if (!success) {
                this.$message({
                  message: message,
                  type: 'error'
                });
              } else {
                
                  //登录成功跳转/table的路由地址
                sessionStorage.setItem('user', JSON.stringify(resultObj.user));
                sessionStorage.setItem('token', resultObj.token); //不要加字符串转换了巨大的坑
                  //修改登录成功后跳转到首页
                this.$router.push({ path: '/echarts' });
              }

Home.vue前端主页

		//退出登录
		logout: function () {
			var _this = this;
			this.$confirm('确认退出吗?', '提示', {
				//type: 'warning'
			}).then(() => {
				sessionStorage.removeItem('user');
				sessionStorage.removeItem('token');
				_this.$router.push('/login');
			}).catch(() => {

			});

Main.js

//拦截器 
axios.interceptors.request.use(config => {
    if (sessionStorage.getItem('token')) {
        // 让每个请求携带token--['X-Token']为自定义key 请根据实际情况自行修改
        config.headers['X-Token'] = sessionStorage.getItem('token')
    }
    console.debug('config',config)
    return config
}, error => {
    // Do something with request error
    Promise.reject(error)
})

2）服务端变为通过token来唯一标识session

Shirospring配置文件
  <!--session管理器-->
    <bean id="sessionManager" class="cn.itsource.shiro.util.CrmSessionManager"/>

    <!--shiro的核心对象-->
    <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
        <property name="sessionManager" ref="sessionManager"/>
        <!--配置realm-->
        <property name="realm" ref="authRealm"/>
    </bean>

CrmSessionManager

/**
 *
 * 传统结构项目中，shiro从cookie中读取sessionId以此来维持会话，
 * 在前后端分离的项目中（也可在移动APP项目使用），我们选择在ajax的请求头中传递sessionId，
 * 因此需要重写shiro获取sessionId的方式。
 * 自定义CrmSessionManager类继承DefaultWebSessionManager类，重写getSessionId方法
 *
 */
public class CrmSessionManager extends DefaultWebSessionManager {

    private static final String AUTHORIZATION = "X-TOKEN";

    private static final String REFERENCED_SESSION_ID_SOURCE = "Stateless request";

    public CrmSessionManager() {
        super();
    }

    @Override
protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
    //取到jessionid
        String id = WebUtils.toHttp(request).getHeader(AUTHORIZATION);
        HttpServletRequest request1 = (HttpServletRequest) request;
        //如果请求头中有 X-TOKEN 则其值为sessionId
        if (!StringUtils.isEmpty(id)) {
            System.out.println(id+"jjjjjjjjj"+request1.getRequestURI()+request1.getMethod());
            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);
        }
    }
}
跨域预检查放行 OPTIONS每次跨域

cors跨域处理时,每次都要跨域预检查,也就是发一个options请求,这种请求shiro应该放行

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">

<bean id="myAuthc" class="cn.itsource.shiro.util.MyAuthenticationFilter"/>

    <!--shiro的过滤器配置-->
    <bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
        <property name="securityManager" ref="securityManager"/>
        <property name="loginUrl" value="/s/login"/>
        <property name="successUrl" value="/s/index"/>
        <property name="unauthorizedUrl" value="/s/unauthorized"/>
        <property name="filters">
            <map>
                <entry key="myAuthc" value-ref="myAuthc"/>
            </map>
        </property>
        <property name="filterChainDefinitions">
            <value>
                /login = anon
                /** = myAuthc
            </value>
        </property>
    </bean>

MyAuthenticationFilter

/**
* 自定义身份认证过滤器
*/
public class MyAuthenticationFilter extends FormAuthenticationFilter {

   @Override
   protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
       //如果是OPTIONS请求，直接放行
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       String method = httpServletRequest.getMethod();
       System.out.println(method);
       if("OPTIONS".equalsIgnoreCase(method)){
           return true;
       }
       return super.isAccessAllowed(request, response, mappedValue);
   }
}
UserContext保存登录用户

实现

/**
 * 当前登录用户相关
 */
public class UserContext {
    private static final String CURRENT_LOGIN_USER=  "loginUser";

    /**
     * 设置当前登录用户
     * @param employee
     */
    public static void setUser(Employee employee){
        Subject currentUser = SecurityUtils.getSubject();
        currentUser.getSession().setAttribute(CURRENT_LOGIN_USER,employee);
    }

    /**
     * 获取当前登录用户
     * @return  employee
     */
    public static Employee getUser(){
        Subject currentUser = SecurityUtils.getSubject();
        return (Employee) currentUser.getSession().getAttribute(CURRENT_LOGIN_USER);
    }
}
dsqzzzz
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
springmvc+shiro+maven 实现登录认证与权限授权管理
08-29
要使用 Shiro，我们需要在 maven 项目中加入 Shiro 相关的 jar 包。以下是 Shiro 的依赖项： ```xml <!-- shiro --> <groupId>org.apache.shiro <artifactId>shiro-core <version>1.2.1 <groupId>org.apache...
springmvc+spring+shiro+cas单点登录实例
01-11
springmvc+spring+shiro+cas单点登录实例 加入了登录验证码认证，修改了下首页样式，不过样式没有弄好，很丑的，有空自己再弄下 说明：cas-server是单点登录服务端，用的是maven项目，但是WEB-INF里面的lib目录下面...
Maven_Spring_Shiro 实例
zhiguoliu11的专栏
12-29 748
LoginController.javapackage com.guo.controller;import org.apache.shiro.SecurityUtils; import org.apache.shiro.authc.UsernamePasswordToken; import org.apache.shiro.subject.Subject; import org.springfram
shiro的maven依赖包
m0_67391518的博客
04-07 1883
spring + springmvc + shiro所需引入的shiro以及shiro集成到spring的包，maven依赖如下： org.apache.shiro shiro-core 1.2.1 org.apache.shiro shiro-spring 1.2.1 org.apache.shiro shiro-web 1.2.1 org.apache.shiro shiro-ehcache 1.2.1
Shiro框架基本使用
最新发布
weixin_51722520的博客
08-02 382
SpringBoot+mybatis+MySQL+Shiro框架整合
Spring、SpringMVC、Shiro、Maven
inexaustible的博客
02-10 961
1、Spring框架就像一个家族，有众多衍生产品例如：boot、security、jpa等等。但它们的基础都是Spring的ioc、aop等；ioc提供了依赖注入的容器，aop解决了面向横切面编程，然后在此两者的基础上实现了其他产品的高级功能；2、SpringMVC主要解决WEB开发的问题，是基于Servlet的一个MVC框架，通过XML配置，统一开发前端视图和后端逻辑。
shiro笔记（三）maven项目集成shiro的第一个项目，实现认证和判断权限；加密及凭证匹配器
一天不写代码难受的博客
08-06 1452
目录搭建maven项目框架 Shiro是不依赖于容器的，所以建立一个普通的Maven项目就可以。 搭建maven项目框架 以上是刚创建的maven项目架构 以下导入shiro依赖 <dependencies> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifac
spring mvc、apache shiro、mysql 框架搭建,基于maven构建
07-26
在IT领域，构建高效、安全且可扩展的Web应用程序常常依赖于框架的组合使用。本项目结合了Spring MVC、Apache Shiro...Maven的加入则确保了项目的整洁性和构建效率。这样的组合对于开发企业级Java Web应用是非常理想的。
【项目原型】spring+spring mvc+mybatis+shiro+maven+bootstrap+ajax+json+分页+逆向工程
05-03
【项目原型】spring+spring mvc+mybatis+shiro+maven+bootstrap+ajax+json+分页+逆向工程 包含现在最流行的技术框架，快速部署各种应用，加入shiro权限框架，安全，美观，你值得拥有
shiro-demo使用redis做缓存.zip
12-01
例如，对于Maven项目，可以添加如下依赖： ```xml <groupId>org.apache.shiro <artifactId>shiro-redis <version>1.7.2 <groupId>redis.clients <artifactId>jedis <version>3.7.0 ``` 2. 配置...
maven与shiro的整合
方圆几里的博客
04-26 2682
前言：最近在看一些shiro 的东西，看的也不是很明白，关于shiro 的研究这里就不详解了，这里只说下shiro 在web 开发中的集成(注： 这里引用的是别人的博文) 1：首先创建maven 项目 2：配置pom.xml 添加框架依赖包 project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.o
Maven搭建Spring+SpringMVC+Mybatis+Shiro项目详解
soo_co的专栏
12-18 291
一. 环境搭建： 1. 开发工具：myeclipse 2014 / IDEA； 2. maven管理版本：apache-maven-3.0+； 3. jdk 1.7.0+ 4. Tomcat8.0 二：工程搭建： 1、修改pom.xml添加对应的包依赖 ? 1 2 3 4 5 6 7 8 9 10 ...
简述 · Apache shiro的用法以及和maven工程的整合思路
oschina_41740100的博客
05-12 962
一、shiro的应用场景和介绍        实现项目中的权限的管理    二、shiro的优点易于使用 - 易用性是这个项目的最终目标。提供易于理解的 Java Security API。广泛性 - 没有其他安全框架可以达到Apache Shiro宣称的广度，它可以为你的安全需求提供“一站式”服务。灵活性 - Apache Shiro可以工作在任何应用环境中。虽然它工作在Web、EJB和IoC环...
Apache Shiro不同maven模块-10
javaZhong的博客
04-24 696
如果您想通过Maven获得Shiro，请使用“Maven Usage”下列出的标记 Artifact Maven用法 笔记 shiro-all 不建议 包含Shiro的所有二进制功能（无依赖关系），在某些构建环境（例如Ant）中很有用。但是，在Maven构建中不建议这样做，因为它不会保留正确的依赖关系元数据，这可能导致Maven无法正常工作。对于Maven构建，强烈建...
springboot集成shiro安全框架
乐昊的博客
12-04 478
一、引入maven配置 1 2 3 4 5 <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.4.0</version> </dependency> ...
Apache Shiro 简介
drnrrwfs的博客
09-01 1771
Apache Shiro 是一个强大并且灵活的开源的安全框架，它能很好的处理 authentication（认证）, authorization(授权), enterprise session management（企业会话管理）和cryptography（密码加密）。Apache Shiro最重要的目标就是易于使用和理解。安全有时候会非常的复杂，甚至是痛苦的，但是它并不一定如此的。一个框架屏蔽复杂性， 如有可能暴露一个干净，直观的API，简化了开发人员的努力，保障他们的应用程序的安全。...
Apache Shiro(一）
qq_42847719的博客
01-01 1198
如同上面提到的，Realm 是 shiro 和你的应用程序安全数据之间的“桥”或“连接”，当实际要与安全相关的数据进行交互如用户执行身份认证（登录）和授权验证（访问控制）时，shiro 从程序配置的一个或多个Realm 中查找这些数据，你需要配置多少个 Realm 便可配置多少个 Realm（通常一个数据源一个），shiro 将会在认证和授权中协调它们。是不是需要所有方面的验证都成功？简单就是不同的角色用户只能访问指定的信息 ，我们需要知道用户有那些角色，用户有那些权限 ，包结构和之前的一致3-3。
org/apache/shiro可以使用Maven导入嘛
05-28
是的，你可以使用Maven导入org/apache/shiro。在Maven项目的pom.xml文件中，你可以添加以下依赖项来导入Shiro： ``` <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-core</artifactId> <version>1.7.1</version> </dependency> ``` 根据你的实际需要，你也可以添加其他Shiro模块或插件的依赖项。例如，如果你需要使用Shiro的Spring支持，你可以添加以下依赖项： ``` <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</artifactId> <version>1.7.1</version> </dependency> ``` 注意：在使用Shiro之前，你需要先了解它的基本概念和使用方法，并配置相应的Shiro安全策略。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值