构建安全高效的Java Web应用：Spring, SpringMVC, MyBatis, Shiro综合教程 ...

本文还有配套的精品资源，点击获取  

  简介：在企业级Java Web应用开发中，Spring、SpringMVC、MyBatis和Shiro框架起到了核心作用。Spring框架支持依赖注入和面向切面编程，SpringMVC用于实现MVC架构，MyBatis负责数据库操作的机动性，而Shiro提供全面的安全性控制。本教程深入解说了这些框架的结合使用方法，并通过"shirodemo"项目介绍了Shiro的安全功能，包括身份验证、授权、会话管理和过滤器等。通过本课程，开发者可以掌握如何将这些技能整合至实际项目中，以实现高效和安全的Web应用开发。

1. Spring框架的依赖注入和面向切面编程

依赖注入（DI）的原理与优势

  依赖注入是Spring框架的核心特性之一，它实现了控制反转（IoC）的设计原则，答应对象间的松耦合。在依赖注入中，对象的创建和依赖关系的维护由容器管理，而不是由对象本身来创建或查找资源。这样做的优势在于进步了组件的复用性、增加了体系的可测试性和可维护性。

1. // 示例：使用 @Autowired 进行依赖注入
2. @Component
3. public class MyService {
4.     private MyDao myDao;
6.     @Autowired
7.     public void setMyDao(MyDao myDao) {
8.         this.myDao = myDao;
9.     }
11.     public void performTask() {
12.         myDao.executeTask();
13.     }
14. }

复制代码

在上面的代码示例中，  MyService  类通过  @Autowired  注解自动注入了  MyDao  类的实例。这种方式简化了对象的依赖关系管理，并使得单元测试可以更容易地更换  MyDao  的实现。
面向切面编程（AOP）的概念和应用

  面向切面编程是一种编程范式，答应开发者将横切关注点（如日志、安全性和事务管理等）从业务逻辑中分离出来。Spring通过AOP提供了一种声明式的服务，用于设置和管理切面。

1. // 示例：使用 @Aspect 定义切面
2. @Aspect
3. @Component
4. public class LoggingAspect {
5.     @Before("execution(* com.example.service.*.*(..))")
6.     public void logBefore(JoinPoint joinPoint) {
7.         // 日志记录逻辑
8.         System.out.println("Before method: " + joinPoint.getSignature().getName());
9.     }
10. }

复制代码

在上面的切面示例中，  LoggingAspect  类通过  @Before  注解定义了一个前置关照，它会在  com.example.service  包下任何类的任何方法执行前运行。通过这种方式，可以集中处理雷同日志记录这样的横切关注点，而无需在每个业务逻辑中显式编写重复的代码。
  通过依赖注入和面向切面编程，Spring框架极大地简化了Java企业应用的开发，进步了开发效率和代码的可维护性。在后续章节中，我们将深入探讨SpringMVC、MyBatis以及Shiro框架，并展示如安在实际项目中综合运用这些技能来构建强盛的应用。
2. SpringMVC的模子-视图-控制器（MVC）架构实现

  SpringMVC 是 Spring 框架的一部分，它通过分离控制器、模子、视图等组件来简化 web 应用程序的开发。下面将详细探讨 SpringMVC 的核心组件分析、数据绑定与表单处理以及非常处理与拦截器的实现。
2.1 SpringMVC的核心组件分析

  在 SpringMVC 中，MVC 架构被抽象为几个核心组件：控制器（Controller）、请求到处理程序的映射（Handler Mapping）、模子和视图解析器（Model and ViewResolver）。
2.1.1 控制器（Controller）的职责与实现

  控制器负责处理用户请求并返反响应。在 SpringMVC 中，控制器通常是被  @Controller  注解标注的类。

1. @Controller
2. public class MyController {
3.     @RequestMapping("/hello")
4.     public String handleRequest(Model model) {
5.         model.addAttribute("message", "Hello, SpringMVC!");
6.         return "helloView";
7.     }
8. }

复制代码

在上面的代码中，  @RequestMapping("/hello")  表明  handleRequest  方法处理对  /hello  的请求。方法参数  Model  用于添加模子数据，返回的字符串是视图的逻辑名称。
2.1.2 视图解析器（ViewResolver）的设置与选择

  视图解析器负责解析视图名称，并将其映射到实际的视图技能。SpringMVC 提供了多种视图解析器，例如  InternalResourceViewResolver  。

1. <bean id="viewResolver"
2.       class="org.springframework.web.servlet.view.InternalResourceViewResolver">
3.     <property name="prefix" value="/WEB-INF/views/"/>
4.     <property name="suffix" value=".jsp"/>
5. </bean>

复制代码

这段 XML 设置了一个视图解析器，它会在  /WEB-INF/views/  目次下寻找 JSP 文件。例如，返回的视图名称为  helloView  ，则实际解析的 JSP 文件是  /WEB-INF/views/helloView.jsp  。
2.2 SpringMVC的数据绑定与表单处理

  数据绑定是将 HTTP 请求数据映射到 Java 对象的过程。SpringMVC 提供了强盛的数据绑定功能。
2.2.1 数据绑定机制及其实现方式

  SpringMVC 通过  @ModelAttribute  和  @RequestParam  等注解来实现数据绑定。

1. @Controller
2. public class FormController {
3.     @RequestMapping("/processForm")
4.     public String processForm(@RequestParam("name") String name, Model model) {
5.         model.addAttribute("message", "Processed name: " + name);
6.         return "resultView";
7.     }
8. }

复制代码

在这个例子中，  @RequestParam("name")  表明从请求中提取名为  name  的参数，并将其绑定到方法参数  name  上。
2.2.2 表单提交的处理流程与技巧

  处理表单提交时，一个常见的技巧是使用  @ModelAttribute  来绑定复杂对象。

1. public class User {
2.     private String name;
3.     private String email;
4.     // getters and setters
5. }
7. @Controller
8. public class FormController {
9.     @RequestMapping("/userForm")
10.     public String showForm(User user) {
11.         // 绑定用户对象到模型
12.         return "userForm";
13.     }
15.     @RequestMapping("/userFormSubmit")
16.     public String submitForm(@ModelAttribute("user") User user) {
17.         // 直接处理提交的用户对象
18.         return "resultView";
19.     }
20. }

复制代码

在上面的代码中，用户起首通过  showForm  方法显示一个表单，用户填写后提交到  userFormSubmit  方法。  @ModelAttribute("user")  会自动将表单数据绑定到  User  对象的属性上。
2.3 SpringMVC的非常处理与拦截器

  SpringMVC 提供了机动的非常处理机制和拦截器，用于增强应用的健壮性。
2.3.1 非常处理的计谋与实践

  非常处理可以通过  @ExceptionHandler  注解在一个控制器内部处理，大概使用  @ControllerAdvice  来全局处理非常。

1. @ControllerAdvice
2. public class GlobalExceptionHandler {
3.     @ExceptionHandler(Exception.class)
4.     public String handleException(Exception ex, Model model) {
5.         model.addAttribute("errorMessage", ex.getMessage());
6.         return "errorView";
7.     }
8. }

复制代码

这个  GlobalExceptionHandler  类通过  @ControllerAdvice  注解声明为全局非常处理器。当发生非常时，全部控制器抛出的  Exception  将被  handleException  方法处理，结果视图为  errorView  。
2.3.2 拦截器（Interceptor）的创建和应用

  拦截器在请求处理之前或之后提供执行代码的机会。

1. public class MyInterceptor implements HandlerInterceptor {
2.     @Override
3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
4.         // 在请求处理之前调用
5.         return true;
6.     }
7.     @Override
8.     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
9.         // 在请求处理之后，视图渲染之前调用
10.     }
12.     @Override
13.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
14.         // 在整个请求结束之后调用，也就是在DispatcherServlet渲染了视图执行。
15.     }
16. }

复制代码

要使用拦截器，需要在 Spring 设置中注册它：

1. <mvc:interceptors>
2.     <mvc:interceptor>
3.         <mvc:mapping path="/**"/>
4.         <bean class="com.example.MyInterceptor"/>
5.     </mvc:interceptor>
6. </mvc:interceptors>

复制代码

以上展示了如何创建一个拦截器，并在 Spring 设置文件中声明，以便它能拦截对全部路径的请求。
  在本章节中，我们详细分析了 SpringMVC 的核心组件，深入探讨了数据绑定与表单处理的方法，以及非常处理与拦截器的实现计谋。这些组件共同构建了 SpringMVC 的模子-视图-控制器架构，使其成为构建动态 web 应用程序的首选框架。
3. MyBatis框架与数据库操作的集成

  在本章中，我们将深入探讨MyBatis框架，以及它是如何与数据库操作集成的。MyBatis 是一个半自动化的ORM（Object Relational Mapping）框架，它提供了一种新的方式来与数据库进行交互。通过SQL映射文件，开发者可以镌汰大量的JDBC代码和手动设置参数以及获取结果集的工作。MyBatis 将Java对象映射到SQL语句，并将查询结果集映射回Java对象。
3.1 MyBatis的设置和映射机制

3.1.1 设置文件的结构与选项

  MyBatis的设置文件通常命名为  mybatis-config.xml  ，它位于类路径的根目次。该设置文件包含MyBatis的行为设置，如数据库毗连管理、事务管理、缓存设置和SQL映射文件的位置。

1. <?xml version="1.0" encoding="UTF-8" ?>
2. <!DOCTYPE configuration
3.         PUBLIC "-//***//DTD Config 3.0//EN"
4.         "***">
5. <configuration>
6.     <properties resource="db.properties"/> <!-- 1. 数据库连接信息 -->
7.     <environments default="development"> <!-- 2. 环境配置 -->
8.         <environment id="development">
9.             <transactionManager type="JDBC"/> <!-- 事务管理器配置 -->
10.             <dataSource type="POOLED"> <!-- 数据源配置 -->
11.                 <property name="driver" value="${driver}" />
12.                 <property name="url" value="${url}" />
13.                 <property name="username" value="${username}" />
14.                 <property name="password" value="${password}" />
15.             </dataSource>
16.         </environment>
17.     </environments>
18.     <mappers> <!-- 3. SQL映射文件配置 -->
19.         <mapper resource="org/mybatis/example/BlogMapper.xml"/>
20.     </mappers>
21. </configuration>

复制代码

• properties ：设置外下属性文件。
  
• environments ：定义数据库环境，可以设置多个。
  
• transactionManager ：事务管理器的类型。
  
• dataSource ：数据源类型和设置信息。
  
• mappers ：映射器文件的位置。
  

3.1.2 SQL映射文件与动态SQL的使用

  SQL映射文件是MyBatis的核心，它答应开发者定义SQL语句，并映射Java对象和数据库结果集。通过  <select>  ,  <insert>  ,  <update>  ,  <delete>  标签，可以创建对应的SQL操作映射。

1. <mapper namespace="org.mybatis.example.BlogMapper">
2.     <select id="selectBlog" resultType="Blog">
3.         SELECT * FROM blog WHERE id = #{id}
4.     </select>
5.     <insert id="insertBlog" parameterType="Blog">
6.         INSERT INTO blog (id, title, author, content)
7.         VALUES (#{id}, #{title}, #{author}, #{content})
8.     </insert>
9.     <!-- 动态SQL -->
10.     <select id="selectBlogIf" resultType="Blog">
11.         SELECT * FROM blog
12.         <where>
13.             <if test="title != null">
14.                 AND title like #{title}
15.             </if>
16.             <if test="author != null and author.name != null">
17.                 AND author_name like #{author.name}
18.             </if>
19.         </where>
20.     </select>
21. </mapper>

复制代码

• namespace ：映射器命名空间，通常是接口的完全限定名。
  
• id ：映射器中语句的唯一标识符。
  
• parameterType ：传入参数类型。
  
• resultType ：返回结果类型。
  

  动态SQL使用  <if>  ,  <choose>  ,  <where>  ,  <set>  等标签，以构建可重用的SQL片断，答应复杂的查询逻辑。
3.2 MyBatis的缓存计谋和性能优化

3.2.1 一级缓存与二级缓存的工作原理

  MyBatis具有两种缓存计谋：一级缓存（本地缓存）和二级缓存（全局缓存）。
  一级缓存是默认开启的，它在同一个SqlSession中存储查询结果，如果SqlSession执行了雷同的查询，MyBatis将直接从缓存中获取结果，无需查询数据库。一旦SqlSession关闭，一级缓存就会被扫除。
  二级缓存可以跨多个SqlSession，它基于namespace进行划分。为了使用二级缓存，必须在设置文件中启用  <cache>  标签，并确保映射的语句可以或许被缓存。
3.2.2 缓存优化的计谋与实践

  为了优化MyBatis的缓存，需要遵照以下实践：

• 使用适合的缓存计谋：根据应用需求和数据访问模式选择合适的缓存级别。
  
• 适当设置缓存：例如，设置合适的逾期时间和引用计谋。
  
• 制止缓存击穿：在缓存失效时，可以使用缓存预热或懒加载计谋。
  
• 使用合适的缓存大小：制止内存溢出和频仍的垃圾接纳。
  

3.3 MyBatis的事务管理与毗连池设置

3.3.1 事务管理机制的理解与应用

  MyBatis对事务的管理通常依赖于底层的数据库毗连（JDBC或毗连池）。事务管理包括了事务的创建、提交和回滚等操作。通过在设置文件中设置  <transactionManager>  ，可以设置事务的管理类型为  JDBC  或  MANAGED  。
  使用MyBatis时，开发者可以通过SqlSessionFactory和SqlSession来管理事务。通常，SqlSession的生命周期是从调用  openSession()  方法开始，到调用  close()  方法结束。
3.3.2 毗连池的设置与性能监控

  MyBatis答应开发者通过设置毗连池来优化数据库毗连管理。毗连池可以镌汰创建和销毁数据库毗连的开销，进步性能。
  在设置文件中，使用  <dataSource>  元素和其子元素  <property>  设置毗连池，常用毗连池的实现有DBCP、C3P0等。

1. <dataSource type="POOLED">
2.     <property name="driver" value="com.mysql.jdbc.Driver"/>
3.     <property name="url" value="jdbc:mysql://localhost:3306/mydatabase"/>
4.     <property name="username" value="root"/>
5.     <property name="password" value="password"/>
6.     <!-- 以下是连接池的配置 -->
7.     <property name="poolMaximumActiveConnections" value="100"/>
8.     <property name="poolMaximumIdleConnections" value="10"/>
9. </dataSource>

复制代码

性能监控可以通过日志或第三方监控工具来进行。通过监控可以实时了解数据库毗连池的状态，如活跃毗连数、空闲毗连数、平均获取毗连时间等。
小结

  在本章节中，我们深入了解了MyBatis框架的设置和映射机制，探讨了SQL映射文件的结构和动态SQL的使用方法。同时，我们学习了MyBatis的缓存计谋，包括一级缓存和二级缓存的工作原理，以及如何通过优化计谋进步缓存性能。此外，我们还讨论了如何使用毗连池进行数据库毗连管理，并介绍了事务管理的基本知识。接下来的章节将介绍Shiro安全框架的入门知识以及它的高级应用和最佳实践。
4. Shiro的安全框架入门和身份验证机制

4.1 Shiro的核心组件和架构概述

4.1.1 认证（Authentication）与授权（Authorization）简介

  Shiro框架是Java范畴广泛使用的一个安全框架，它简便而强盛，可以或许提供身份验证、授权、会话管理以及加密功能。为了理解Shiro的基本工作原理，起首要明白它所处理的两个核心安全概念：认证与授权。
  认证（Authentication）是辨认用户身份的过程，即确定“你是谁”的过程。在实际应用中，这通常涉及检查用户提供的凭据（如用户名和暗码）是否与体系中存储的凭据相匹配。Shiro支持多种认证方式，包括但不限于表单认证、基本HTTP认证、摘要认证等。
  授权（Authorization）则是在认证成功后，决定用户可以访问哪些资源的过程。它涉及权限检查和访问控制，确保用户只能访问他们被授权的资源。在Shiro中，授权通常通过脚色（Role-Based Access Control, RBAC）来实现，脚色定义了一系列权限，而用户则被分配一个或多个脚色。
4.1.2 Shiro的架构组件分析

  Shiro的架构设计是围绕三个重要概念展开的：Subject（主体）、SecurityManager（安全管理器）、Realms（范畴）。

• Subject ：代表当前与软件交互的用户或第三方服务，险些全部的Shiro操作都是通过Subject来完成的。Subject可以是人，也可以是第三方服务、守护进程账户、时钟守护任务，大概别的与软件交互的任何东西。
  
• SecurityManager ：是Shiro架构的心脏，负责和谐和管理Shiro各组件。它负责管理全部的Subject，而且在内部通过Realm来获取安全数据。SecurityManager是Shiro框架与应用代码进行交互的桥梁。
  
• Realms ：充当了Shiro与安全数据源之间的桥梁或毗连器。当需要执行认证（登录）和授权（访问控制）时，Shiro会从设置好的Realm中查找用户及其权限信息。Realms是自定义的，每个Realm负责从一个或多个数据源获取安全数据。
  

  接下来，将深入探讨Shiro的身份验证流程以及如安在实际应用中创建自定义认证计谋。
4.2 Shiro的身份验证流程与实践

4.2.1 身份验证流程详解

  身份验证在Shiro中是通过Subject实例完成的。当用户尝试访问体系时，通常需要提供用户名和暗码，这些凭据随后会被通报给一个AuthenticationToken实例。 AuthenticationToken随后会被通报给SecurityManager，SecurityManager则负责将这个Token通报给设置好的Realm进行处理。
  在身份验证流程中，重要步骤如下：

• 用户提交用户名和暗码，这些信息通过AuthenticationToken被封装。
  
• SecurityManager接收到AuthenticationToken后，会调用Realm的  getAuthenticationInfo  方法。
  
• Realm负责查询数据库或其他安全数据源，以确定提供的凭据是否匹配。
  
• 一旦Realm验证了凭据，就会返回一个AuthenticationInfo对象，此中包含验证信息。
  
• SecurityManager接收到这些信息后，会进行终极的验证确认。
  
• 如果整个过程成功，用户会被认为是已认证的；如果失败，则会抛出相应的非常。
  

4.2.2 自定义认证计谋与登录流程

  尽管Shiro提供了多种开箱即用的认证选项，但在某些环境下，我们大概需要实现本身的认证逻辑。以下是一个简单的自定义认证计谋的步骤：

• 实现自定义Realm： 自定义Realm需要继承自一个基础的Realm类，比如  AuthorizingRealm  ，并实现  doGetAuthenticationInfo  方法。
  

1. public class MyCustomRealm extends AuthorizingRealm {
3.     @Override
4.     protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
5.         // 获取用户名和密码
6.         UsernamePasswordToken upToken = (UsernamePasswordToken) token;
7.         String username = upToken.getUsername();
8.         // 这里通常查询数据库或其他存储介质
9.         User user = getUserByUsername(username);
10.         if (user == null) {
11.             // 用户不存在
12.             throw new UnknownAccountException("No account found for user [" + username + "]");
13.         }
14.         // 检查密码是否匹配
15.         if (!matches(user.getPassword(), upToken.getPassword())) {
16.             // 密码错误
17.             throw new IncorrectCredentialsException("Password for account [" + username + "] was incorrect!");
18.         }
19.         // 如果认证信息正确无误，返回一个认证信息对象
20.         return new SimpleAuthenticationInfo(user, user.getPassword(), getName());
21.     }
22. }

复制代码

• 设置自定义Realm： 在Spring设置文件中注册自定义Realm。
  

1. <bean id="myCustomRealm" class="com.example.MyCustomRealm">
2.     <!-- 自定义Realm的配置 -->
3. </bean>

复制代码

• 设置SecurityManager使用自定义Realm： 在Shiro的设置中指定SecurityManager使用自定义的Realm。
  

1. <bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
2.     <property name="realm" ref="myCustomRealm" />
3. </bean>

复制代码

• 实现用户身份验证： 在控制器中实现登录逻辑，调用Subject的  login  方法。
  

1. @RequestMapping("/login")
2. public String login(String username, String password, Model model) {
3.     UsernamePasswordToken token = new UsernamePasswordToken(username, password);
4.     Subject subject = SecurityUtils.getSubject();
5.     try {
6.         subject.login(token);
7.         return "redirect:/home";
8.     } catch (AuthenticationException e) {
9.         model.addAttribute("errorMessage", e.getMessage());
10.         return "login";
11.     }
12. }

复制代码

通过上述步骤，可以实现自定义的Shiro认证计谋，并将其融入到现有的登录流程中。接下来，我们将探讨Shiro的授权实践，包括基于脚色的访问控制（RBAC）和会话管理。
4.3 Shiro的授权实践与会话管理

4.3.1 基于脚色的访问控制（RBAC）

  在Shiro中，权限的授权通常基于脚色来进行，这是一种广泛认可的权限管理方法。每个脚色都与一组权限相干联，而用户则被分配一个或多个脚色。Shiro通过这种方式简化了访问控制的复杂性，使得权限的管理更加直观。
  在Shiro中，授权重要是通过  doCheckAccess  方法实现的，这个方法需要由Realm实现。下面是一个简单的示例：

1. @Override
2. protected boolean doCheckAccess(Subject subject, Resource resource, String permission) throws AuthorizationException {
3.     // 获取用户角色
4.     Set<String> roles = getRoles(subject);
5.     for (String role : roles) {
6.         if (hasRole(role)) {
7.             return true;
8.         }
9.     }
10.     return false;
11. }

复制代码

此中  hasRole  方法和  getRoles  方法需要根据实际环境来实现。
4.3.2 会话管理与Web会话的集成

  Shiro会话管理是与Web应用的HTTP会话集成的，其设计可以无缝地与任何Servlet容器，比如Tomcat或Jetty，协同工作。Shiro的会话管理不仅仅限于Web应用，也可以在非Web环境下工作，如Swing应用大概下令行工具。
  Shiro提供了一个会话管理的抽象，这使得我们可以不依赖于底层的Servlet容器，同时提供了丰富的API来操作会话。例如，获取当前用户会话：

1. Session session = SecurityUtils.getSubject().getSession();

复制代码

以下是一个简单的会话操作示例：

1. @RequestMapping("/doSomething")public String doSomething() {    // 获取当前用户的会话    Session session = SecurityUtils.getSubject().getSession();
2.     // 设置会话属性    session.setAttribute("someKey", "aValue");    // 获取会话属性    String value = (String) session.getAttribute("someKey");    // 使会话逾期    session.stop();    return "success";}

复制代码

在实际的Web应用中，Shiro也支持通过过滤器来管理Web会话，比如  SessionTimeoutFilter  可以在会话逾期时自动跳转到指定的URL。
  接下来，我们将详细探讨Shiro的高级应用和最佳实践，以及如安在项目中整合Spring、SpringMVC、MyBatis和Shiro实现企业级的安全应用。
5. Shiro的高级应用和最佳实践

5.1 Shiro的安全过滤器与Web安全

  Shiro的安全过滤器是实现Web应用安全的核心组件之一。通过设置和使用这些过滤器，开发者可以确保应用的安全性能，例如会话挟制防护、URL访问控制等。
  5.1.1 安全过滤器的设置与应用场景 Shiro的过滤器基于标准的Servlet过滤器实现，可以通过XML设置或编程式设置进行集成。以下是一个基本的安全过滤器设置示例：

1. <filter>
2.     <filter-name>shiroFilter</filter-name>
3.     <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
4.     <init-param>
5.         <param-name>targetFilterLifecycle</param-name>
6.         <param-value>true</param-value>
7.     </init-param>
8. </filter>
9. <filter-mapping>
10.     <filter-name>shiroFilter</filter-name>
11.     <url-pattern>/*</url-pattern>
12. </filter-mapping>

复制代码

该设置会拦截全部的请求，并将它们通报给Shiro的  ShiroFilterFactoryBean  进行处理。
  在  ShiroFilterChainDefinitions  中，可以定义规则，决定哪些URL需要哪些权限。例如：

1. @Bean
2. public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
3.     ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
4.     shiroFilterFactoryBean.setSecurityManager(securityManager);
5.     Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
6.     filterChainDefinitionMap.put("/login.jsp", "anon");
7.     filterChainDefinitionMap.put("/logout", "logout");
8.     filterChainDefinitionMap.put("/**", "authc");
9.     shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
10.     return shiroFilterFactoryBean;
11. }

复制代码

上述代码中，定义了一个匿名访问的  /login.jsp  ，一个退出登录的  /logout  ，以及其他全部路径都需要登录后才能访问。
  5.1.2 在Web应用中整合Shiro进行访问控制 整合Shiro进行访问控制需要在应用中定义脚色和权限，然后在URL路径上应用这些安全规则。这样，只有具有相应权限的用户才能访问特定资源。
  例如，假设我们有一个管理用户列表的页面，该页面需要特定的脚色才能访问：

1. filterChainDefinitionMap.put("/admin/user/list", "roles[admin]");

复制代码

这个设置意味着只有具备  admin  脚色的用户可以访问该URL。如果未通过Shiro的安全检查，Shiro将拦截该请求，并可以重定向到登录页面或显示未授权错误。
5.2 Shiro的缓存管理和性能提升

  Shiro提供了多种缓存管理机制，这些机制对于提升应用性能非常关键，尤其是对于需要频仍访问用户信息和权限数据的应用。
  5.2.1 缓存的设置与管理计谋 在Shiro中，缓存是通过  CacheManager  设置的。默认环境下，Shiro内置了一个简单的内存缓存实现，但在生产环境中，保举使用更强盛的缓存实现，如EhCache、Guava或Redis。

1. @Bean
2. public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() {
3.     EhCacheManagerFactoryBean cmfb = new EhCacheManagerFactoryBean();
4.     cmfb.setCacheManagerConfigFile("classpath:ehcache.xml");
5.     return cmfb;
6. }
8. @Bean
9. public EhCacheManager cacheManager() {
10.     EhCacheManager cacheManager = new EhCacheManager();
11.     cacheManager.setCacheManagerConfigFile("classpath:ehcache.xml");
12.     return cacheManager;
13. }

复制代码

以上设置创建了一个EhCache的  CacheManager  ，并指定了缓存设置文件  ehcache.xml  的位置。
  5.2.2 缓存对应用性能的影响分析 缓存的使用可以显着镌汰数据库访问的次数，从而进步应用的响应速度和处理能力。通过缓存用户认证信息和权限数据，Shiro可以快速返回验证结果，镌汰CPU和内存的使用。
  在实际应用中，缓存的计谋需要根据应用的详细需求来定制。例如，针对需要高度同等性的体系，大概需要设置较短的缓存时间。而对于数据更新不频仍的体系，则可以设置较长的缓存时间以镌汰资源消耗。
5.3 Shiro的API设计与框架集成最佳实践

  Shiro的设计目标是提供简单易用、易于理解的安全框架，它的API设计以简便和直观著称。
  5.3.1 Shiro简便API的设计理念 Shiro的API设计遵照了以下几个核心原则：

• 简单性 ：API应易于学习和使用。
  
• 直观性 ：API的命名和结构应直观反映其用途。
  
• 机动性 ：应答应开发者自定义实现以适应差别场景。
  

  例如，认证过程可以简单到一行代码：

1. Subject subject = SecurityUtils.getSubject();
2. if (subject.isAuthenticated()) {
3.     // 认证成功逻辑
4. } else {
5.     // 认证失败逻辑
6. }

复制代码

在Shiro中，  Subject  代表当前与软件交互的实体（通常是用户）。通过获取Subject实例，开发者可以执行诸如身份验证、授权等操作。
  5.3.2 框架集成的最佳实践与核心设置案例 集成Shiro到现有项目时，最佳实践包括：

• 同一认证入口 ：将全部用户请求通过Shiro的  Subject  来处理认证和授权。
  
• 按需加载 ：使用Shiro的懒加载特性，按需加载资源和权限数据。
  
• 独立的权限数据源 ：将权限信息与业务数据分离，便于管理和维护。
  

  核心设置案例通常涉及安全管理器（  SecurityManager  ）、范畴对象（如用户、脚色、权限）、以及相干的服务实现。例如：

1. @Bean
2. public SecurityManager securityManager(CredentialsMatcher credentialsMatcher) {
3.     DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
4.     securityManager.setRealm(myRealm(credentialsMatcher));
5.     securityManager.setSessionManager(sessionManager());
6.     return securityManager;
7. }

复制代码

上述代码定义了一个  SecurityManager  ，设置了自定义的  Realm  和会话管理器。
5.4 集成案例分析：Spring+SpringMVC+MyBatis+Shiro的实际应用

  集成多个框架是Java企业级应用开发的常态，了解如何将Shiro与Spring、SpringMVC和MyBatis等框架集成，对于实现安全、高效的应用至关重要。
  5.4.1 框架集成的团体流程与关键步骤 框架集成的流程大抵如下：

• 环境搭建 ：确保项目已经设置好Maven或Gradle依赖管理。
  
• 依赖引入 ：在项目中引入Spring、SpringMVC、MyBatis和Shiro的依赖。
  
• 设置文件编写 ：编写相应的设置文件，如Spring的XML设置文件、MyBatis的映射文件等。
  
• 安全设置 ：根据需要设置Shiro的安全计谋，包括用户认证、授权规则、缓存等。
  
• 业务逻辑开发 ：在业务层集成Shiro的API，确保全部权限判断和用户交互都颠末Shiro处理。
  

  5.4.2 实际项目中的设置与优化经验分享 在实际项目中，以下是一些常见的设置和优化经验：

• 设置Shiro的SessionDAO ：为包管会话的恒久性和集群化部署的兼容性，可以通过设置Shiro的  EnterpriseCacheSessionDAO  来实现。
  
• 自定义realm ：为了实现更机动的用户数据验证和授权逻辑，通常需要自定义  Realm  。
  
• 权限分层设计 ：合理设计权限的层级结构可以有效管理复杂的权限关系，保举使用基于脚色的访问控制模子（RBAC）。
  

  通过以上步骤，可以有效地将Shiro集成到使用Spring和MyBatis的Java Web应用中，构建出既安全又高效的应用体系。
   本文还有配套的精品资源，点击获取  

  简介：在企业级Java Web应用开发中，Spring、SpringMVC、MyBatis和Shiro框架起到了核心作用。Spring框架支持依赖注入和面向切面编程，SpringMVC用于实现MVC架构，MyBatis负责数据库操作的机动性，而Shiro提供全面的安全性控制。本教程深入解说了这些框架的结合使用方法，并通过"shirodemo"项目介绍了Shiro的安全功能，包括身份验证、授权、会话管理和过滤器等。通过本课程，开发者可以掌握如何将这些技能整合至实际项目中，以实现高效和安全的Web应用开发。
   本文还有配套的精品资源，点击获取  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。