实验十四 应用Spring AOP进行访问权限控制

Spring的AOP配置(2011-04-01 20:38:58)转载标签：分类：SSH框架springaop配置获取参数it1.先写一个普通类：package com.spring.aop;public class Common {public void execute(String username,String password){ System.out.println("------------------普通类----------------");}}2.写一个切面类，用于合法性校验和日志添加：package com.spring.aop;public class Check {public void checkValidity(){System.out.println("------------------验证合法性----------------"); }public void addLog(JoinPoint j){System.out.println("------------------添加日志----------------");Object obj[] = j.getArgs();for(Object o :obj){System.out.println(o);}System.out.println("========checkSecurity=="+j.getSignature().getName());//这个是获得方法名}}3.配置AOP，使用XML方式：（注意红色标志的内容）<?xml version="1.0" encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="common" class="mon"/><bean id="check" class="com.spring.aop.Check"/><aop:config><aop:aspect id="myAop" ref="check"><aop:pointcut id="target" expression="execution(*mon.execute(..))"/><aop:before method="checkValidity" pointcut-ref="target"/><aop:after method="addLog" pointcut-ref="target"/></aop:aspect></aop:config>注意：execution(* com.spring.aop.*.*(..))"/这样写应该就可以了这是com.aptech.jb.epet.dao.hibimpl 包下所有的类的所有方法。

springbootsecurity权限控制--@PreAuthorize的使⽤1. 说明security 鉴权⽅式常⽤的有两种配置，1、配置⽂件中配置；2、使⽤注解标注；他们都是基于 acess 表达式，如果需要⾃定义逻辑的鉴权认证，只需要⾃定义access 表达式即可。

本⽂只选取注解的⽅式，来讲解默认的 access 和⾃定义的 access 表达式2.基于注解的使⽤2.1 使⽤前提条件：注解默认不可⽤，通过开启注解：在配置类中开启注解 @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) @Secured：专门判断⽤户是否具有⾓⾊，可以写在⽅法或类上，参数以 ROLE_ 开头@PreAuthorize\PostAuthorize： PreAuthorize 访问的类或⽅法执⾏前判断权限，⽽ PostAuthorize 在执⾏之后，Post 基本不⽤；允许与 ROLE_ 开头。

2.2 基于默认的access表达式在登录的时候，需要将⽤户权限返回给security；security才能实现权限控制功能；具体步骤：登录时，实现 UserDetailService，重写 loadUserByUsername(String userName)⽅法。

根据 userName 来实现⾃⼰的业务逻辑返回 UserDetails 的实现类，需要⾃定义User 类实现 UserDetails，⽐较重要的⽅法是 getAuthorities()，⽤来返回该⽤户所拥有的权限@Datapublic class LoginUser implements UserDetails, Serializable {...@Overridepublic Collection<? extends GrantedAuthority> getAuthorities() {// 根据⾃定义逻辑来返回⽤户权限，如果⽤户权限返回空或者和拦截路径对应权限不同，验证不通过if (!permissions.isEmpty()) {List<GrantedAuthority> list = new ArrayList<GrantedAuthority>();for (String temp : permissions) {GrantedAuthority au = new SimpleGrantedAuthority(temp);list.add(au);}return list;}return null;}}然后在需要权限控制的controller⽅法上，添加注解@PreAuthorize("hasAuthority('..*')")；其中@PreAuthorize括号中就是access表达式。

SpringBoot监控管理模块actuator没有权限的问题解决⽅法SpringBoot 1.5.9 版本加⼊actuator依赖后，访问/beans 等敏感的信息时候报错，如下Tue Mar 07 21:18:57 GMT+08:00 2017There was an unexpected error (type=Unauthorized, status=401).Full authentication is required to access this resource.肯定是权限问题了。

有两种⽅式： 1.关闭权限：application.properties添加配置参数management.security.enabled=false2.添加权限（未测试）：<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-security</artifactId></dependency>在property中配置权限ID描述敏感（Sensitive）autoconfi g 显⽰⼀个auto-configuration的报告，该报告展⽰所有auto-configuration候选者及它们被应⽤或未被应⽤的原因truebeans显⽰⼀个应⽤中所有Spring Beans的完整列表true configprops显⽰⼀个所有@ConfigurationProperties的整理列表true dump执⾏⼀个线程转储true env暴露来⾃Spring　ConfigurableEnvironment的属性truehealth 展⽰应⽤的健康信息（当使⽤⼀个未认证连接访问时显⽰⼀个简单的'status'，使⽤认证连接访问则显⽰全部信息详情）falseinfo显⽰任意的应⽤信息falsemetrics展⽰当前应⽤的'指标'信息truemappings显⽰⼀个所有@RequestMapping路径的整理列表trueshutdown允许应⽤以优雅的⽅式关闭（默认情况下不启⽤）truetrace显⽰trace信息（默认为最新的⼀些HTTP请求）true总结以上所述是⼩编给⼤家介绍的SpringBoot 监控管理模块actuator没有权限的问题解决⽅法，希望对⼤家有所帮助，如果⼤家有任何疑问请给我留⾔，⼩编会及时回复⼤家的。

java中aop的应用实例
1. 日志记录：在应用中添加日志记录功能，通过aop中的拦截器，在方法执行前后记录方法的调用信息、输入参数和返回结果，方便排查问题和分析性能。

2. 权限控制：通过aop中的拦截器，在方法执行前进行权限验证，检查当前用户是否有权限执行该方法，如果没有权限则拦截方法的执行，并返回相应的错误提示信息。

3. 缓存管理：通过aop中的拦截器，将方法的返回结果缓存起来，下次再次调用该方法时可以直接从缓存中获取，避免重复计算或查询数据库，提升系统性能。

4. 事务管理：通过aop中的拦截器，在方法执行前后控制事务的开启、提交或回滚，保证方法执行的一致性和完整性。

5. 性能监控：通过aop中的拦截器，在方法执行前后记录方法的执行时间，通过统计和分析方法的执行时间，可以判断出系统的性能瓶颈所在，从而优化系统性能。

6. 异常处理：通过aop中的拦截器，在方法执行过程中捕获异常，并进行相应的处理，例如记录异常信息、发送邮件或短信通知等。

7. 参数校验：通过aop中的拦截器，在方法执行前对输入参数进行校验，确保参数的合法性和有效性，避免因参数错误引发的潜在问题。

8. 分布式事务：通过aop中的拦截器和分布式事务管理框架，实现多个数据库操作在一个事务中进行提交或回滚，确保数据的一致性。

（10条消息）springboot⾃定义注解使⽤AOP实现请求参数解密以及响应数据加密⼀、前⾔本篇⽂章将依托与SpringBoot平台，⾃定义注解⽤来标识接⼝请求是否实现加密解密。

使⽤AOP切⾯来具体操作解密加密，实现对源代码的低耦合，不在原基础上做很⼤的改动。

本篇⽂章的所有⽰例，都上传到我的github中，欢迎⼤家拉取测试，欢迎star github实现要求：1. ⾃定义⼀个注解@Secret，⽤来标识需要实现加密解密作⽤在Controller类上，表⽰此Controller类的所有接⼝都实现加密解密作⽤来单⼀⽅法上，表⽰此接⼝⽅法需要实现加密解密2. 使⽤AOP切⾯编程实现在接⼝⽅法执⾏之前将前端的加密参数解密并重新赋给接⼝参数在接⼝⽅法响应之后，将返回的数据进⾏加密返回3. 在配置⽂件中配置，是否开启全局的加密解密操作实现流程：1. 前端请求的接⼝将请求参数json通过AES加密⽣成加密字符串，然后将加密字符串通过名为encyptStr字段传递给后端。

2. AOP前置⽅法拦截，将encyptStr字符串通过AES解密得到原始请求参数json，将json映射为请求⽅法的参数对象User。

3. 接⼝通过参数成功响应，并将响应数据直接返回。

4. AOP后置⽅式拦截，将响应参数data字段⾥的数据AES加密，并返回给前端5. 前端收到请求响应，通过code判断请求是否成功，AES加密data字段得到需要的数据。

⼆、实现操作1. 创建SPRINGBOOT项⽬创建⼀个SpringBoot项⽬，导⼊必要的maven依赖。

使⽤AOP切⾯需要导⼊AOP的启动器lombok是⼀个通过注解简化代码的⼯具，在idea中使⽤需要安装lombok插件json转换⼯具，apache⼯具类pom.xml1. <!-- web依赖 -->2. <dependency>3. <groupId>org.springframework.boot</groupId>4. <artifactId>spring-boot-starter-web</artifactId>5. </dependency>6.7. <!-- AOP切⾯依赖 -->8. <dependency>9. <groupId>org.springframework.boot</groupId>10. <artifactId>spring-boot-starter-aop</artifactId>11. </dependency>12.13. <!-- lombok⼯具 -->14. <dependency>15. <groupId>org.projectlombok</groupId>16. <artifactId>lombok</artifactId>17. <optional>true</optional>18. </dependency>19.20. <!-- json操作类 -->21. <dependency>22. <groupId>com.alibaba</groupId>23. <artifactId>fastjson</artifactId>24. <version>1.2.52.sec06</version>25. </dependency>26. <!-- String⼯具包 -->27. <dependency>28. <groupId>mons</groupId>29. <artifactId>commons-lang3</artifactId>30. <version>3.9</version>31. </dependency>2. ⾃定注解@SECRET我们通过⾃定义的注解，来标识类或接⼝，告诉AOP哪些类或⽅法需要执⾏加密解密操作，更加的灵活。

SpringAOP的原理和应用场景SpringAOP（Aspect-Oriented Programming）是Spring框架中的一个重要组成部分，它提供了一种通过预定义的方式，将横切关注点（Cross-cutting Concerns）与业务逻辑进行解耦的机制。

本文将介绍SpringAOP的原理及其在实际应用场景中的应用。

一、SpringAOP的原理SpringAOP基于代理模式（Proxy Pattern）实现。

在SpringAOP中，通过生成与原始类（被代理类）具有相同接口的代理类，将横切逻辑编织到业务逻辑中。

在运行时，当调用代理类的方法时，会在方法执行前、后或异常抛出时插入相应的横切逻辑代码。

具体而言，SpringAOP使用了以下几个核心概念：1. 切面（Aspect）：切面是横切逻辑的模块化单元，它包含了一组通知（Advice）和切点（Pointcut）。

2. 通知（Advice）：通知定义了实际的横切逻辑代码，并规定了何时执行该代码。

SpringAOP提供了五种类型的通知：前置通知（Before）、后置通知（After）、返回通知（After-returning）、异常通知（After-throwing）和环绕通知（Around）。

3. 切点（Pointcut）：切点指定了在哪些连接点（Join Point）上执行通知。

连接点可以是方法调用、属性访问等程序执行的点。

4. 连接点（Join Point）：连接点是程序执行过程中的一个特定点，如方法调用前、方法调用后等。

通知通过切点来选择连接点。

5. 织入（Weaving）：织入是将切面应用到目标对象，并创建代理对象的过程。

织入可以在编译时、类加载时或运行时进行。

二、SpringAOP的应用场景SpringAOP可应用于各种场景，用于解决跨越多个模块或类的横切关注点问题。

以下是一些常见的SpringAOP应用场景：1. 日志记录：通过在关键方法的前后插入日志代码，实现对系统运行状态的监控和记录。

SpringAOP⽰例与实现原理总结——传统springaop、基于切⾯注⼊、基于@Asp。

⼀、代码实践1）经典的Spring Aop经典的spring aop，是基于动态代理技术的。

实现⽅式上，最常⽤的是实现MethodInterceptor接⼝来提供环绕通知，创建若⼲代理，然后使⽤ProxyBeanFactory配置⼯⼚bean，⽣成拦截器链，完成拦截。

⽰例如下：1package demo.spring;23import org.aopalliance.intercept.MethodInterceptor;4import org.aopalliance.intercept.MethodInvocation;5import org.junit.Test;6import org.junit.runner.RunWith;7import org.springframework.beans.factory.annotation.Autowired;8import org.springframework.test.context.ContextConfiguration;9import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;1011 @RunWith(SpringJUnit4ClassRunner.class)12 @ContextConfiguration("classpath:spring-config.xml")13public class TraditionalSpringAopDemo {14 @Autowired15private Service proxy;1617 @Test18public void test() {19 proxy.execute("hello world!");20 }21 }2223interface Service {24void execute(String str);25 }2627class ServiceImpl implements Service {28 @Override29public void execute(String str) {30 System.out.println("execute invoke: " + str);31 }32 }3334class Interceptor1 implements MethodInterceptor {35 @Override36public Object invoke(MethodInvocation methodInvocation) throws Throwable {37 System.out.println("interceptor1,before invoke");38 Object ret = methodInvocation.proceed();39 System.out.println("interceptor1,after invoke");40return ret;41 }42 }4344class Interceptor2 implements MethodInterceptor {45 @Override46public Object invoke(MethodInvocation methodInvocation) throws Throwable {47 System.out.println("interceptor2,before invoke");48 Object ret = methodInvocation.proceed();49 System.out.println("interceptor2,after invoke");50return ret;51 }52 }xml⽂件配置：1<?xml version="1.0" encoding="UTF-8"?>2<beans xmlns="/schema/beans"3 xmlns:xsi="/2001/XMLSchema-instance"4 xmlns:context="/schema/context"5 xmlns:aop="/schema/aop"6 xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd /schema/context /schema/context/sprin 78<context:component-scan base-package="demo.spring"/>910<bean class="demo.spring.ServiceImpl" id="service"></bean>11<bean class="demo.spring.Interceptor1" id="interceptor1"></bean>12<bean class="demo.spring.Interceptor2" id="interceptor2"></bean>13<bean class="org.springframework.aop.framework.ProxyFactoryBean" id="proxy">14<property name="target" ref="service"/>15<property name="interceptorNames">16<list>17<value>interceptor1</value>18<value>interceptor2</value>19</list>20</property>21</bean>22</beans>结果：interceptor1,before invokeinterceptor2,before invokeexecute invoke: hello world!interceptor2,after invokeinterceptor1,after invoke可以看到拦截链的执⾏过程与拦截器顺序的关系。

aop常见的使用场景AOP常见的使用场景AOP（面向切面编程）是一种编程思想，可以将横切关注点（例如日志记录、性能监测、事务管理等）从主业务逻辑中分离出来，以提高代码的可维护性和可重用性。

在实际的软件开发中，AOP有着广泛的应用场景。

本文将介绍AOP常见的使用场景。

1. 日志记录日志记录是一种常见的AOP应用场景。

通过在关键的业务方法前后插入日志记录的切面，可以记录系统的运行状态、输入参数、输出结果以及错误信息等。

这样，在出现问题时，可以追踪日志并分析问题根源，提高问题定位和解决的效率。

2. 性能监测性能监测是另一个常见的AOP应用场景。

通过在关键的方法前后插入性能监测的切面，可以统计方法的执行时间、调用次数等信息，以便分析系统的性能瓶颈并进行优化。

性能监测可以帮助开发人员找出系统中的性能问题，提高系统的响应速度和吞吐量。

3. 安全检查安全检查是AOP的另一个重要应用场景。

通过在敏感方法前后插入安全检查的切面，可以验证用户的权限、身份认证信息等，以保护系统的安全性。

安全检查可以防止未授权的操作和恶意攻击，提高系统的安全性和可靠性。

4. 事务管理事务管理是一种常见的AOP应用场景。

通过在关键的方法前后插入事务管理的切面，可以实现事务的自动提交或回滚。

事务管理可以确保数据库操作的一致性和完整性，避免数据丢失或脏数据的产生。

5. 异常处理异常处理是AOP的另一个常见应用场景。

通过在关键的方法前后插入异常处理的切面，可以捕获并处理方法中的异常。

异常处理可以有效地处理系统中的异常情况，避免系统崩溃或数据损坏。

6. 缓存管理缓存管理是AOP的另一个重要应用场景。

通过在关键的方法前后插入缓存管理的切面，可以实现数据的缓存和读取。

缓存管理可以提高系统的响应速度和吞吐量，减轻数据库的负载。

7. 参数校验参数校验是一种常见的AOP应用场景。

通过在方法调用前插入参数校验的切面，可以验证方法的输入参数的合法性。

参数校验可以避免因为非法参数导致的系统错误和安全漏洞。

SpringSecurity怎样使⽤注解控制权限⼀般的系统在权限设计上，都会分为⾓⾊、权限（RDBC），复杂⼀点的可能会有⽤户组、组织之类的概念。

⽤户的权限是写死的，对应于后台的接⼝或者资源，是没办法改变的，⼀般不对⽤户开放修改权限。

管理员⽤户可以通过给⾓⾊分配权限的⽅式，来实现访问控制。

所以当我们写过滤器，或者⽤⼀些安全框架时（⽐如Shiro，Spring Security），也需要将可变的“⾓⾊”，转化为不可变的“权限”，注⼊到框架中。

具体的可以看我之前写的⼀篇（）注⼊当前⽤户的权限后，就需要进⾏访问控制了。

常见的做法有1、路径⽐对之前有个项⽬⽤过⼀次，定义⼀个过滤器，添加到security的过滤链中，在这个过滤器中做这么⼀件事：分析当前访问路径所需要的权限，检查当前⽤户是否具有该权限，做⼀个对⽐，根据对⽐结果来决定当前⽤户是否可以访问该资源。

这种做法的好处是代码的⼊侵性不⾼，不需要再每个接⼝上加注解。

但相对来说，显得不那么直观，可读性⽐较差，所以这次换个⽅法。

2、使⽤注解的⽅式SpringSecurity使⽤注解来控制访问时，需要提前开启这个功能。

在配置类上加上注解@Configuration@EnableWebSecurity@EnableGlobalMethodSecurity(prePostEnabled = true)public class SecurityConfig extends WebSecurityConfigurerAdapter {在接⼝中如此使⽤/*** 条件查询*/@PreAuthorize("hasAuthority('IMPORT:SELECT')")@ApiOperation(value = "查询")@GetMapping("/list")public R<Page<Task>> list(TaskDto taskDto){//测试阶段，随机⽣成任务Random random = new Random();//todoint i = random.nextInt(4);if(i == 2) {metroServerAdapterService.reloadShelveTask();}Page<Task> list = taskService.list(taskDto);return R.ok(list);}hasAuthority可以替换成hasRole，虽然可以达到相同的⽬的，但是在使⽤的⽅法上还是有些不同的。

springboot集成shiro——使用RequiresPermissions注解无效在集成Shiro框架中，我们可以使用RequiresPermissions注解来标识方法或者类级别的权限控制。

但是在一些情况下，可能会遇到包括RequiresPermissions注解无效的情况。

下面我将详细介绍一些可能导致RequiresPermissions注解无效的原因，并给出相应的解决办法。

1. 配置文件问题：Shiro框架需要一个shiro.ini文件或者shiro.yml文件来读取权限规则。

如果你没有指定这个配置文件，或者文件路径不正确，那么RequiresPermissions注解就会无效。

解决方法是在application.yml文件中添加以下配置：```shiro:config:file: classpath:shiro.ini``````javapublic ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager)ShiroFilterFactoryBean shiroFilter = new ShiroFilterFactoryBean(;shiroFilter.setSecurityManager(securityManager);// 添加需要进行权限控制的urlMap<String, String> filterChainDefinitionMap = new LinkedHashMap<>(;//...shiroFilter.setFilterChainDefinitionMap(filterChainDefinitio nMap);return shiroFilter;}```3. 自定义Realm问题：如果你使用了自定义的Realm，那么可能是Realm中没有正确配置权限信息导致RequiresPermissions注解无效。