实验十四 应用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注解无效。

用户权限和访问控制测试在计算机系统中，用户权限和访问控制是一项关键的安全措施，旨在确保只有经过授权的用户能够访问系统资源。

为了验证系统的权限管理和访问控制机制的有效性，进行测试是至关重要的。

本文将探讨用户权限和访问控制的测试方法，并介绍一些常用的测试技术和工具。

一、权限测试的目的和重要性用户权限测试的目的是验证系统是否按照预期的方式为用户分配和管理权限。

当用户权限得到正确管理时，他们只能访问其职责范围内的资源，从而保护敏感数据不被未经授权的用户访问。

权限测试可以帮助发现系统中潜在的安全漏洞，以及未正确配置的权限设置，从而及时修复和加强系统的安全性。

二、用户权限测试的方法1. 边界测试：通过尝试使用不同权限级别的用户账户访问系统资源，检查系统对于不同权限级别的响应情况。

测试用例可以包括使用普通用户账户尝试修改系统关键文件、以管理员账户访问受限资源等情况。

2. 角色测试：针对不同的用户角色，验证系统是否正确地为不同角色分配了相应的权限。

测试用例可以包括尝试使用不同的角色账户访问相关资源，检查系统是否正确限制了不同角色的权限。

3. 特权升级测试：测试系统对于特权升级请求的响应情况。

测试用例可以包括通过滥用系统漏洞或执行特定命令等方式尝试升级普通用户权限为管理员权限，检查系统是否正确阻止了非授权的特权升级。

4. 异常情况测试：测试系统在面对异常情况时的权限管理和访问控制反应情况。

测试用例可以包括尝试使用已被禁用的账户登录、尝试越权访问、测试系统对于异常用户行为的阻止等。

三、用户权限测试工具1. Nessus：一款功能强大的漏洞扫描器，可以帮助测试人员发现系统中存在的漏洞和安全隐患，并提供相应的修复建议。

2. OpenVAS：一个开源的漏洞扫描器，提供用户权限测试和漏洞评估的功能，可以帮助测试人员检测系统中的权限配置错误和安全漏洞。

3. Metasploit：一款广泛使用的渗透测试工具，其中包含了丰富的利用模块，可以用于测试系统的用户权限和访问控制机制。

Django框架开发中的权限控制和访问控制在Django框架开发中的权限控制和访问控制Django是一个强大的Python Web框架，广泛应用于各种Web应用的开发中。

在实际的项目中，权限控制和访问控制是非常重要的功能之一。

本文将介绍在Django框架开发中如何实现权限控制和访问控制的方法和技巧。

一、权限控制权限控制是指根据用户的身份、角色或者其他条件，对用户访问系统资源的权限进行限制和控制。

在Django框架中，权限控制可以通过以下几种方式实现。

1. 用户认证Django提供了内置的用户认证系统，可以通过在settings.py中配置AUTHENTICATION_BACKENDS来指定认证后端。

可以使用Django 提供的默认后端，也可以自定义认证后端。

用户登录后可以获取到用户对象，在视图函数或模板中可以通过用户对象来判断用户的权限。

2. 权限装饰器Django提供了一系列的装饰器，比如@login_required、@permission_required等，可以用来装饰视图函数或类视图，从而限制只有满足指定条件的用户才能访问相应的页面或功能。

3. 自定义权限除了使用Django提供的默认权限系统，我们还可以根据实际项目需求自定义权限，例如根据用户角色进行权限控制。

可以通过重写用户模型、使用第三方库或者编写自定义的中间件来实现。

二、访问控制访问控制是指限制用户在系统中访问资源的权限。

在Django框架中，可以通过以下几种方式实现访问控制。

1. URL配置在Django的URL配置中，可以使用正则表达式或路径匹配来限制用户访问特定的URL。

例如，可以使用@login_required装饰器限制只有认证用户才能访问某个URL。

2. 视图控制在视图函数或类视图中，可以通过判断用户的身份、角色或其他条件来限制用户访问相应的页面或功能。

可以使用if语句、条件判断或调用Django提供的各种方法来实现。

Spring中IOC和AOP的深⼊讲解前⾔Spring是⼀个开源框架，Spring是于2003 年兴起的⼀个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍⽣⽽来。

它是为了解决企业应⽤开发的复杂性⽽创建的。

Spring使⽤基本的JavaBean来完成以前只可能由EJB完成的事情。

然⽽，Spring的⽤途不仅限于服务器端的开发。

从简单性、可测试性和松耦合的⾓度⽽⾔，任何Java应⽤都可以从Spring中受益。

简单来说，Spring是⼀个轻量级的控制反转（IoC）和⾯向切⾯（AOP）的容器框架。

这篇⽂章主要讲 Spring 中的⼏个点，Spring 中的 IOC，AOP，下⼀篇说说 Spring 中的事务操作，注解和 XML 配置。

Spring 简介Spring 是⼀个开源的轻量级的企业级框架，其核⼼是反转控制 (IoC) 和⾯向切⾯ (AOP) 的容器框架。

我们可以把 Spring 看成是对象的容器，容器中可以包含很多对象，所以 Spring 有很多强⼤的功能。

⼀句话，Spring 是项⽬中对象的管家，负责管理项⽬中⽤到的所有对象。

所以在项⽬三层架构中，Spring 不属于某⼀特定层。

Spring 的 Hello World想要构建⼀个 Spring 的⼊门程序，我们需要导⼊ 4 个核⼼包和 2 个辅助包，创建⼀个实体类，最主要的是编写核⼼配置⽂件，applicationContext.xml 放在 src 下。

最后写⼀个测试类即可。

此时在测试类中我们不需要在使⽤ new 关键字去创建对象了。

这也正是 Spring 的作⽤所在，会⾃动给我创建对象。

上图展⽰的就是最基本的演⽰，也是很容易就理解了，配置⽂件中配置了 user 对象，我们通过加载配置⽂件来获取对象从⽽避免了使⽤ new 来创建。

aop案例AOP（面向切面编程）是一种编程范式，它通过将横切关注点从业务代码中分离出来，以模块化的方式解决了一些横跨多个对象和层次的关注点。

在实际应用中，AOP可以用于解决各种不同的问题。

下面是一些AOP案例的列举。

1. 日志记录：通过AOP可以很方便地实现日志记录功能，例如记录方法的执行时间、参数、返回值等信息，以便后续的分析和排查问题。

2. 异常处理：AOP可以将异常处理逻辑从业务代码中分离出来，使得代码更加简洁清晰。

例如，可以通过AOP统一处理异常，记录异常信息并进行相应的处理，而不需要在每个方法中都进行异常处理。

3. 权限控制：通过AOP可以实现细粒度的权限控制。

例如，可以定义一个切面，在方法执行前进行权限检查，如果没有权限则抛出异常或进行其他处理。

4. 事务管理：AOP可以很方便地实现事务管理功能。

例如，在方法执行前开启事务，在方法执行后根据方法的执行结果决定是提交事务还是回滚事务。

5. 缓存管理：通过AOP可以实现缓存管理功能，将缓存逻辑从业务代码中分离出来。

例如，在方法执行前检查是否有缓存数据，如果有则直接返回缓存数据，如果没有则执行方法并将结果存入缓存。

6. 性能监控：通过AOP可以实现性能监控功能，记录方法的执行时间、资源占用等信息，并进行相应的统计和分析。

例如，可以定义一个切面，在方法执行前记录开始时间，在方法执行后记录结束时间，计算方法的执行时间。

7. 分布式跟踪：通过AOP可以实现分布式跟踪功能，记录请求在不同的节点上的执行情况，以便进行问题定位和排查。

例如，可以定义一个切面，在方法执行前记录请求的唯一标识，在方法执行后记录执行结果和耗时，将这些信息发送到分布式跟踪系统。

8. 计数统计：通过AOP可以实现计数统计功能，记录方法的调用次数，以便进行性能分析和优化。

例如，可以定义一个切面，在方法执行后增加计数器的值。

9. 定时任务：通过AOP可以实现定时任务功能，定时执行某些方法。

Spring系列之AOP实现的两种⽅式Spring只⽀持XML⽅式⽽没有实现注解的⽅式（也叫AspectJ⽅式）的AOP，所以要使⽤@Aspect注解，只能引⼊AspectJ相关的 jar 包：aopalliance-1.0.jar 和 aspectjweaver.jarSpring的配置⽂件 applicationContext.xml 中引⼊context、aop对应的命名空间；配置⾃动扫描的包，同时使切⾯类中相关⽅法中的注解⽣效，需⾃动地为匹配到的⽅法所在的类⽣成代理对象。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:context="/schema/context"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd/schema/aop /schema/aop/spring-aop-4.0.xsd/schema/context /schema/context/spring-context-4.0.xsd"><!-- 配置⾃动扫描的包 --><context:component-scan base-package="com.qcc.beans.aop"></context:component-scan><!-- ⾃动为切⾯⽅法中匹配的⽅法所在的类⽣成代理对象。

--><aop:aspectj-autoproxy></aop:aspectj-autoproxy></beans>AOP常⽤的实现⽅式有两种，1、采⽤声明的⽅式来实现（基于XML），2、是采⽤注解的⽅式来实现（基于AspectJ）。

SpringBoot——AOP注解式拦截与⽅法规则拦截 AspectJ是⼀个⾯向切⾯的框架，它扩展了Java语⾔。

AspectJ定义了AOP语法，所以它有⼀个专门的编译器⽤来⽣成遵守Java字节编码规范的Class⽂件。

SpringBoot中AOP的使⽤⽅式主要有两种：注解式拦截与⽅法规则拦截，具体使⽤如下⽂所⽰。

⼀、创建⼀个简单springboot 2.03项⽬，添加aop依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId></dependency>　此依赖已包含AspectJ相关依赖包。

⼆、编写拦截规则的注解package com.cenobitor.aop.annotation;import ng.annotation.*;@Target(ElementType.METHOD)@Retention(RetentionPolicy.RUNTIME)@Documentedpublic @interface Action {String name();}注解说明：元注解是指注解的注解，包括@Retention @Target @Document @Inherited四种。

1.@Retention: 定义注解的保留策略@Retention(RetentionPolicy.SOURCE) //注解仅存在于源码中，在class字节码⽂件中不包含@Retention(RetentionPolicy.CLASS) // 默认的保留策略，注解会在class字节码⽂件中存在，但运⾏时⽆法获得，@Retention(RetentionPolicy.RUNTIME) // 注解会在class字节码⽂件中存在，在运⾏时可以通过反射获取到 ⾸先要明确⽣命周期长度 SOURCE < CLASS < RUNTIME ，所以前者能作⽤的地⽅后者⼀定也能作⽤。

SpringBoot实践——AOP实现AOP介绍⼀、AOP AOP（Aspect Oriented Programming），即⾯向切⾯编程，可以说是OOP（Object Oriented Programming，⾯向对象编程）的补充和完善。

OOP引⼊封装、继承、多态等概念来建⽴⼀种对象层次结构，⽤于模拟公共⾏为的⼀个集合。

不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如⽇志功能。

⽇志代码往往横向地散布在所有对象层次中，⽽与它对应的对象的核⼼功能毫⽆关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的⽆关的代码被称为横切（cross cutting），在OOP设计中，它导致了⼤量代码的重复，⽽不利于各个模块的重⽤。

AOP技术恰恰相反，它利⽤⼀种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共⾏为封装到⼀个可重⽤模块，并将其命名为"Aspect"，即切⾯。

所谓"切⾯"，简单说就是那些与业务⽆关，却为业务模块所共同调⽤的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

使⽤"横切"技术，AOP把软件系统分为两个部分：核⼼关注点和横切关注点。

业务处理的主要流程是核⼼关注点，与之关系不⼤的部分是横切关注点。

横切关注点的⼀个特点是，他们经常发⽣在核⼼关注点的多处，⽽各处基本相似，⽐如权限认证、⽇志、事物。

AOP的作⽤在于分离系统中的各种关注点，将核⼼关注点和横切关注点分离开来。

AOP（Aspect Orient Programming），我们⼀般称为⾯向⽅⾯（切⾯）编程，作为⾯向对象的⼀种补充，⽤于处理系统中分布于各个模块的横切关注点，⽐如事务管理、⽇志、缓存等等。

AOP实现的关键在于AOP框架⾃动创建的AOP代理，AOP代理主要分为静态代理和动态代理，静态代理的代表为AspectJ；⽽动态代理则以Spring AOP为代表。