Spring框架aop

最新推荐文章于 2022-09-05 08:01:02 发布
最新推荐文章于 2022-09-05 08:01:02 发布
阅读量73 收藏
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34497272/article/details/109519860
版权

文章目录


Spring4和Spring5下aop的区别(Springboot1+升级到2+)，可查阅 此博客

一、介绍

Spring 框架的一个关键组件是面向方面的编程(AOP)框架。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。

二、为什么使用aop

aop可以将核心业务代码和其他日志类代码解耦，使得核心代码保持纯净，可以将通用方法抽离，方便维护。
开发中在多个模块间有重复的代码，我们通常是怎么处理的？

  1. 复制粘贴(代码冗余，维护困难)
  2. 抽象成一个方法，然后在需要的地方分别调用这个方法(需求多变时，维护困难)
  3. jdk动态代理(可以实现，但是写起来难)
  4. AOP（实现简单，方便维护）

2.1 jdk动态代理

// 核心代码(无入侵)
@Component
public class MyMathCalculator implements Calculator {
    @Override
    public int add(int i,int j){
        int result = i + j;
        return result;
    }
}

// 核心方法的代理类
public class CalcultorProxy {
    /**
     * 为传入的对象创建一个代理对象
     * @param calculator 被代理的对象 要创建代理对象的值
     * @return 代理对象
     */
    public static Calculator getProxy(Calculator calculator){

        // ClassLoader 类加载器
        ClassLoader loader = calculator.getClass().getClassLoader();
        // 实现的所有接口
        Class<?>[] interfaces = calculator.getClass().getInterfaces();
        // 方法执行器
        InvocationHandler h = new InvocationHandler() {
            /**
             *
             * @param proxy 代理对象，给jdk使用的
             * @param method 目标对象的方法
             * @param args 执行目标方法所需参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // 利用反射执行目标方法 invoke即为目标方法执行后返回的值
                System.out.println("jdk动态代理～～～");
                Object invoke = null;
                try {
                    System.out.println("LogUtil-->start-->方法执行前");
                    invoke = method.invoke(calculator, args);
                    System.out.println("LogUtil-->return-->方法执行完成");
                }catch (Exception e){
                    System.out.println("LogUtil-->error-->方法执行失败");
                }finally {
                    System.out.println("LogUtil-->end-->方法执行结束");
                }
                return invoke;
            }
        };
        Object o = Proxy.newProxyInstance(loader, interfaces, h);
        return (Calculator) o;
    }
}

// 测试类
@SpringBootTest
public class test {

    /**
     * 使用jdk动态代理可以和业务代码解耦
     * jdk默认的动态代理，如果对象没有实现任何接口，jdk则不能实现代理
     */
    @Test
    public void test(){
        Calculator calculator = new MyMathCalculator();
        System.out.println(calculator.add(1, 2));

        System.out.println("~~~~~~~~jdk动态代理~~~~~~~~~");
        Calculator proxy = CalcultorProxy.getProxy(calculator);
        int add1 = proxy.add(1,2);
        System.out.println(add1);
    }
}
// 3
// ~~~~~~~~jdk动态代理~~~~~~~~~
// jdk动态代理～～～
// LogUtil-->start-->方法执行前
// LogUtil-->return-->方法执行完成
// LogUtil-->end-->方法执行结束
// 3

三、AOP 核心概念

概念描述
切面（aspect）类是对物体特征的抽象，切面就是对横切关注点的抽象
连接点（joinpoint）被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器
切入点（pointcut）这是一组一个或多个连接点，通知应该被执行
通知（advice）所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类
横切关注点对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

在这里插入图片描述

四、AOP通知的类型

    @Before 方法执行前运行                  前置通知
    @After 方法执行结束运行                  后置通知
    @AfterReturning 方法正常返回时运行        异常通知
    @AfterThrowing 目标方法抛出异常后运行      返回通知
    @Around 环绕                           环绕通知
        spring最强大的通知，合并了以上四种通知。利用反射执行方法，类似于method.invoke(obj,args);
        环绕通知执行顺序要优先其他通知
        
    try {
        @Before
        invoke = method.invoke(calculator, args);
        @AfterReturning
    }catch (Exception e){
        @AfterThrowing
    }finally {
        @After
    }

五、AOP 运用场景

  1. Authentication 权限
  2. Caching 缓存
  3. Context passing 内容传递
  4. Error handling 错误处理
  5. Lazy loading 懒加载
  6. Debugging 调试
  7. logging, tracing, profiling and monitoring 记录 跟踪 优化 校准
  8. Performance optimization 性能优化
  9. Persistence 持久化
  10. Resource pooling 资源池
  11. Synchronization 同步
  12. Transactions 事务

六、AOP实现

5.1 xml方式

  1. 将目标类和切面类通过bean注入到ioc容器中
  2. 使用aop:config配置aop信息
  3. 使用<aop:aspect ref=“logUtil03”>标示那个类为切面类
  4. aop:beforeaop:afteraop:after-throwingaop:after-returningaop:around标示什么时候执行
<?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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
	<!-- 目标类 -->
    <bean id="myMathCalculator04" class="com.guocoffee.spring.aop.aop03.impl.MyMathCalculator04"></bean>
    <!-- 切入类 -->
    <bean id="logUtil03" class="com.guocoffee.spring.aop.aop03.util.LogUtil03"></bean>

    <aop:config>
        <aop:pointcut id="myPointcut" expression="execution(* com.guocoffee.spring.aop.aop03..*(..))"/>
        <!-- 相当于@Aspect -->
        <aop:aspect ref="logUtil03" order="1">
            <aop:before method="logStart" pointcut="execution(* com.guocoffee.spring.aop.aop03..*(..))"></aop:before>
            <aop:after method="logEnd" pointcut-ref="myPointcut"></aop:after>
            <aop:after-throwing method="logError" pointcut-ref="myPointcut" throwing="exception"></aop:after-throwing>
            <aop:after-returning method="logReturn" pointcut-ref="myPointcut" returning="result"></aop:after-returning>
            <aop:around method="myAround" pointcut-ref="myPointcut"></aop:around>
        </aop:aspect>

    </aop:config>
</beans>

public class LogUtil03 {

    public void logStart(JoinPoint joinPoint){
        // 获取目标发放运行是传输的参数
        Object[] args = joinPoint.getArgs();

        // 获取方法签名
        // 方法签名:int com.guocoffee.spring.aop.aop02.impl.MyMathCalculator03.add(int,int)
        Signature signature = joinPoint.getSignature();
        System.out.println("方法签名:"+signature);
        // 获取方法名
        String name = signature.getName();
        System.out.println(name + "方法执行开始-->LogUtil-->start-->方法执行前，参数列表：" + Arrays.toString(args));
    }

    public void logReturn(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行完成返回-->LogUtil-->return-->方法执行完成返回,返回结果：" + result);
    }

    public void logError(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        exception.printStackTrace();
        System.out.println(name + "方法执行异常-->LogUtil-->error-->方法执行失败，异常信息：" + exception);
    }

    public static void logEnd(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行结束LogUtil-->end-->方法执行结束");
    }

    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        // 执行参数
        Object[] args = pjp.getArgs();
        // 执行方法名
        String name = pjp.getSignature().getName();
        Object proceed = null;
        try {
            // @Before
            System.out.println(name + "方法执行开始-->around环绕-->方法执行前，参数列表：" + Arrays.toString(args));
            // 利用反射执行方法，类似于method.invoke(obj,args);
            proceed = pjp.proceed(args);
            // @AfterReturning
            System.out.println(name + "方法执行完成返回-->around环绕-->方法执行完成返回,返回结果：" + proceed);
        } catch (Exception e){
            // @AfterThrowing
            System.out.println(name + "方法执行异常-->around环绕-->方法执行失败，异常信息：" + e);
        } finally {
            // @After
            System.out.println(name + "方法执行结束-->around环绕-->方法执行结束");
        }
        // 返回值，此处返回值是什么，对应方法获取的返回值则是啥
        // 所以此处一定要返回执行反射后返回的值
        return proceed;
    }
}

5.2 注解方式

  1. 将目标类和切面类注入到ioc容器中 @Component
  2. 标示那个是切面类 @Aspect
  3. 在切面类中标示在何时调用切面类 @Before @After @AfterReturning @AfterThrowing @Around
  4. 开启基于注解的aop功能
@Aspect
@Order(1)   // 多个切面时运行顺序按照order小的先执行
@Component
public class LogUtil02 {

    /**
     *
     * try {
     *      @Before
     *      invoke = method.invoke(calculator, args);
     *      @AfterReturning
     * }catch (Exception e){
     *      @AfterThrowing
     * }finally {
     *      @After
     * }
     *
     * @Before 方法执行前运行                  前置通知
     * @After 方法执行结束运行                  后置通知
     * @AfterReturning 方法正常返回时运行        异常通知
     * @AfterThrowing 目标方法抛出异常后运行      返回通知
     * @Around 环绕                           环绕通知
     *
     *
     * Spring4和Spring5执行顺序存在差异
     * 执行顺序（Spring4）：
     *  正常执行：@Before-->@After-->@AfterReturning
     *  异常执行：@Before-->@After-->@AfterThrowing
     * 执行顺序（Spring5）：
     *  正常执行：@Before-->@AfterReturning-->@After
     *  异常执行：@Before-->@AfterThrowing-->@After
     *
     * 切入点表达式
     *      固定写法：execution(访问权限修饰符 返回值类型 全类名.方法名(参数)
     *      通配符：
     *          *
     *              1、匹配一个或多个字符
     *                  execution(public int com.guocoffee.spring.aop.aop02.impl.*.*(int ,int)
     *                  execution(public int com.guocoffee.spring.aop.aop02.impl.MyMath*.*(int ,int)
     *                  execution(public int com.guocoffee.spring.aop.aop02.impl.MyMath*03.*(int ,int)
     *              2、任意参数（第一个参数为int 第二个参数为任意参数）
     *                  execution(public int com.guocoffee.spring.aop.aop02.impl.MyMath*03.*(int ,*)
     *              3、只能匹配一层路径
     *                  execution(public int com.guocoffee.spring.aop.*.impl.MyMath*03.*(..)
     *              4、任意返回值
     *                  execution(public * com.guocoffee.spring.aop.*.impl.MyMath*03.*(..)
     *              5、访问权限修饰符不能写*  可以不写，默认任意修饰符
     *                  execution(* com.guocoffee.spring.aop.*.impl.MyMath*03.*(..)
     *          ..
     *              1、匹配任意参数
     *                  execution(public int com.guocoffee.spring.aop.aop02.impl.MyMath*03.*(..)
     *              2、匹配任意层级
     *                  execution(public int com.guocoffee.spring..impl.MyMath*03.*(..)
     *
     * 最模糊： execution(* *(..)) 或者 execution(* *.*(..))  任意包下的任意类，尽量不要使用
     *
     * && || !
     *
     * && 两个表达式均需要满足
     * || 两个表达式只要满足一个
     * ! 除表达式以外的
     * execution(public int com.guocoffee.spring..impl.MyMath*03.*(..) && execution(public int com.guocoffee.spring..impl.MyMath*02.*(..)
     */

    /**
     * 表达式抽取
     * 1、新建一个无放回值的空方法
     * 2、使用@Pointcut注解，将表达是写入其中
     * 3、@Before("myAspect()") @After("myAspect()") 在注解里直接使用此方法
     */
    @Pointcut("execution(public int com.guocoffee.spring.aop.aop02.impl.*.*(int ,int ))")
    public void myAspect(){};

    @Before("myAspect()")
    public void logStart(JoinPoint joinPoint){
        // 获取目标发放运行是传输的参数
        Object[] args = joinPoint.getArgs();

        // 获取方法签名
        // 方法签名:int com.guocoffee.spring.aop.aop02.impl.MyMathCalculator03.add(int,int)
        Signature signature = joinPoint.getSignature();
        System.out.println("方法签名:"+signature);
        // 获取方法名
        String name = signature.getName();
        System.out.println(name + "方法执行开始-->LogUtil-->start-->方法执行前，参数列表：" + Arrays.toString(args));
    }

    /**
     * returning = "result" 告诉spring，用result来接受执行方法返回的值
     * double result:只接受double类型的返回值
     * Object result:任意类型的返回值
     * @param joinPoint 封装了链接点的所有信息
     * @param result 返回结果
     */
    @AfterReturning(value = "execution(public int com.guocoffee.spring.aop.aop02.impl.*.*(int ,int ))",returning = "result")
    public void logReturn(JoinPoint joinPoint,Object result){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行完成返回-->LogUtil-->return-->方法执行完成返回,返回结果：" + result);
    }

    /**
     * throwing = "exception" 告诉spring，用exception来接受运行方法时出现的异常
     *
     * NullPointerException exception:只接受空指针异常
     * Exception exception：接受所有异常
     *
     * @param joinPoint 封装了链接点的所有信息
     * @param exception 接受错误信息
     */
    @AfterThrowing(value = "execution(public int com.guocoffee.spring.aop.aop02.impl.*.*(int ,int ))",throwing = "exception")
    public void logError(JoinPoint joinPoint,Exception exception){
        String name = joinPoint.getSignature().getName();
        exception.printStackTrace();
        System.out.println(name + "方法执行异常-->LogUtil-->error-->方法执行失败，异常信息：" + exception);
    }

    @After("execution(public int com.guocoffee.spring.aop.aop02.impl.*.*(int ,int ))")
    public static void logEnd(JoinPoint joinPoint){
        String name = joinPoint.getSignature().getName();
        System.out.println(name + "方法执行结束LogUtil-->end-->方法执行结束");
    }

    /**
     * 环绕通知是Spring中最强大的，集合了其他四种
     */
    @Around("myAspect()")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        // 执行参数
        Object[] args = pjp.getArgs();
        // 执行方法名
        String name = pjp.getSignature().getName();
        Object proceed = null;
        try {
            // @Before
            System.out.println(name + "方法执行开始-->around环绕-->方法执行前，参数列表：" + Arrays.toString(args));
            // 利用反射执行方法，类似于method.invoke(obj,args);
            proceed = pjp.proceed(args);
            // @AfterReturning
            System.out.println(name + "方法执行完成返回-->around环绕-->方法执行完成返回,返回结果：" + proceed);
        } catch (Exception e){
            // @AfterThrowing
            System.out.println(name + "方法执行异常-->around环绕-->方法执行失败，异常信息：" + e);
        } finally {
            // @After
            System.out.println(name + "方法执行结束-->around环绕-->方法执行结束");
        }
        // 返回值，此处返回值是什么，对应方法获取的返回值则是啥
        // 所以此处一定要返回执行反射后返回的值
        return proceed;
    }

}

<?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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:component-scan base-package="com.guocoffee.spring.aop.aop02"></context:component-scan>
    <!--
        使用注解开启aop
        1、将目标类和切面类注入到ioc容器中 @Component
        2、标示那个是切面类 @Aspect
        3、在切面类中标示在何时调用切面类 @Before @After @AfterReturning @AfterThrowing @Around
        4、开启基于注解的aop功能
    -->
    <!-- 开启基于注解的aop功能，需要aop命名空间 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
郭咖啡
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring框架之Spring AOP
JavaMonsterr的博客
06-09 123
让我们首先定义一些核心的AOP概念和术语：Spring AOP包括以下类型的Advice：Around advice是最通用的一种Advice。由于Spring AOP和AspectJ一样，提供了全面的Advice类型，我们建议你使用功能最弱的Advice类型来实现所需的行为。例如，如果你只需要用一个方法的返回值来更新缓存，那么你最好实现一个After returning advice，而不是一个Around advice，尽管Around advice可以完成同样的事情。使用最具体的Advice类型可以提
Spring框架（中） AOP
deserts的博客
10-18 179
Spring（中） AOP （一）代理模式 1.静态代理 静态代理在使用时,需要定义接口或者父类,被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类。 举例： package com.deserts.proxy.staticproxy; /** * @ClassName ProxyTest * @Description TODO * @Author deserts * @Date 2020/10/16 12:12 */ interface IShoeFactory{
Spring框架之AOP详解
qq_45515347的博客
09-05 1999
Spring AOP 详解，并实现demo
spring 框架 aop 操作
Json的知识梦工厂
03-14 873
// spring 框架 aop 操作 (准备工作) // 1. 一般基于 AspectJ 实现 AOP操作 // 什么是 AspectJ? // AspectJ 不是Spring 组成部分 独立的AOP框架 , 一般把 AspectJ 和 Spring 框架一起用 进行AOP 操作 //2. 基于 AspectJ 实现AOP操作 // 1） 基于xml 配置文件实现 // 2） 基于注解方式实现 一般使用这个 // 3. 在项目工程里面 引入 AOP相关依赖 /
细说Spring——AOP详解（AOP概览）
热门推荐
啦啦啦的博客
05-30 53万+
一、对AOP的初印象 首先先给出一段比较专业的术语（来自百度）： 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个 热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑 的各个部分进行隔离，从而...
Spring框架AOP静态代理.pdf
09-20
Spring框架AOP静态代理 AOP（Aspect-Oriented Programming，面向切面编程）是一种编程范式，旨在通过将横切关注点（如日志记录、事务管理等）从主业务逻辑中分离出来，提高代码的模块化和可维护性。 静态代理是在...
Spring框架AOP面向切面JAR
10-15
aspectjrt-1.5.2.jar aspectjweaver-1.9.1.jar spring-aop-5.0.8.RELEASE.jar spring-aspects-5.0.8.RELEASE.jar
Spring框架基于AOP实现简单日志管理步骤解析
08-19
Spring框架基于AOP实现简单日志管理步骤解析 在本篇文章中，我们将详细介绍如何使用Spring框架基于AOP（Aspect-Oriented Programming，面向方面编程）来实现简单日志管理步骤解析。AOP是一种编程范式，旨在将横切...
Spring框架,AOP,Spring整合Mybatis
01-13
Spring框架是Java开发中最广泛应用的轻量级框架之一，它提供了强大的依赖注入（DI）以及面向切面编程（AOP）功能。AOP是Spring框架的核心特性，它允许程序员将关注点分离，使得业务逻辑与系统服务如日志、事务管理等...
Spring框架AOP配置异常和环绕通知(一)
Let_Me的博客
07-26 2828
在之前的博客中，我已经给大家讲解了Spring框架中AOP的两种实现方式(Schema-based和AspectJ)，并分别简单配置了它们的前后置通知。今天给大家补充其它的两种通知配置方法——异常和环绕通知，首先给大家回顾一下Spring框架中AOP有哪些通知类型： 通知类型 接口 描述 Around(环绕) org.aopalliance.intercept.Method...
泛微协同办公平台E-cology9.0版本后台维护手册(D)--流程引擎.docx
09-03
泛微后端技术文档
A fast intra mode decision algorithm combining neighboring info
09-03
论文提出了一种用于H.264/AVC高配置文件的快速帧内模式决策算法，旨在降低编码复杂度。 算法基于当前块的内容以及邻块的空间连续性来选择最佳预测模式。 通过使用重建的邻域像素，不同的预测模式会导致不同的残差块，算法利用残差块的特征来辅助模式决策。 提出的算法使用绝对变换差之和（SATD）来衡量残差块，并使用最可能的模式来指示邻块预测模式的影响。 实验结果表明，与全搜索算法相比，所提出的算法在编码性能略有下降的情况下，有效降低了帧内预测的复杂度
《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软-MbccmsP.zip
09-03
c 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip《会员卡刷卡消费管理系统专业版》是一款集系统设置、会员管理、充值积分、会员消费、查询统计于一体的软_MbccmsP.zip 《会
基于springboot学生选课系统设计与实现.docx
09-03
基于springboot学生选课系统设计与实现.docx
【天线阻抗】基于matlab耦合偶极子天线阻抗计算【含Matlab源码 7447期】.mp4
09-03
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【无线电】基于matlab认知无线电网络中协同频谱传感的优化【含Matlab源码 7449期】.mp4
09-03
Matlab研究室上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描视频QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作
【误码率仿真】基于matlab 2x2MIMO-LDPC系统误码率仿真【含Matlab源码 7446期】.zip
09-03
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
小程序-同乐居商城：购物车合算（源码）.zip
最新发布
09-03
小程序-同乐居商城：购物车合算（源码）.zip
新增1986-2017年农村固定观察点数据，三农数据大全(全新整理)
09-03
1、资源内容地址：https://blog.csdn.net/2301_79696294/article/details/141282812 2、代码特点：今年全新，手工精心整理，放心引用，数据来自权威，相对于其他人的控制变量数据准确很多,适合写论文做实证用 ，不会出现数据造假问题 3、适用对象：大学生，本科生，研究生小白可用，容易上手！！！ 3、课程引用: 经济学，地理学，城市规划与城市研究，公共政策与管理，社会学，商业与管理 【新增数据】 全国农村固定观察点数据服务是由农业农村部主导的逐年农户层级跟踪调查数据库，具有全国代表性以及权威性，是目前全国样本数量规模最大的农户层级数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值