Spring5学习笔记—AOP编程

Springgif.gif

✅作者简介：大家好，我是Leo，热爱Java后端开发者，一个想要与大家共同进步的男人😉😉
🍎个人主页：Leo的博客
💞当前专栏： Spring专栏
✨特色专栏： MySQL学习
🥭本文内容：Spring5学习笔记—AOP编程
🖥️个人小站 ：个人博客，欢迎大家访问
📚个人知识库： 知识库，欢迎大家访问

1. 静态代理设计模式

1.1 为什么需要代理设计模式

  • 在JavaEE分层开发开发中，那个层次对于我们来讲最重要

    DAO ---> Service --> Controller 

JavaEE分层开发中，最为重要的是Service层

  • Service层中包含了哪些代码？

    Service层中 = 核心功能(几十行 上百代码) + 额外功能(附加功能)
1. 核心功能
   业务运算
   DAO调用
2. 额外功能(事务、日志、性能...)
   1. 不属于业务
   2. 可有可无
   3. 代码量很小

  • 额外功能书写在Service层中好不好？

    Controller层（Service层的调用者）除了需要核心功能，还需要这些额外功能。

    但是从软件设计者角度看：Service层最好不要写额外功能。

  • 现实生活中的解决方式

    image-20230815111510825

代理模式是一种比较好理解的设计模式。简单来说就是 我们使用代理对象来代替对真实对象(real object)的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。

代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后你可以增加一些自定义的操作。

代理模式: 为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。

被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象

举个例子：当我们工作之后需要出去租房子，房东张贴广告带我看房子，最后签合同，但是房东只想坐着签合同并不想到处跑着看房子，于是就找了一个中介专门来宣传广告并且带租户看房子，而房东只负责签合同收钱！中介在这里就可以看作是代理你的代理对象，代理的行为（方法）是带租户看房子。

img

1.2 代理设计模式分析

2.1 概念

通过代理类，为原始类（目标）增加额外的功能 好处：利于原始类(目标)的维护

2.2 名词解释

1. 目标类 原始类 
   指的是 业务类 (核心功能 --> 业务运算 DAO调用)
2. 目标方法，原始方法
   目标类(原始类)中的方法 就是目标方法(原始方法)
3. 额外功能 (附加功能)
   日志，事务，性能

2.3 代理开发的核心要素

代理类 = 实现和目标类相同的接口 + 在同名方法中添加额外功能 + 调用原始类同名方法

房东 ---> public interface UserService{
               m1
               m2
          }
          UserServiceImpl implements UserService{
               m1 ---> 业务运算 DAO调用
               m2 
          }
          UserServiceProxy implements UserService
               m1
               m2

2.4 编码

静态代理：为每一个原始类，手动编写一个代理类 (.java .class)

image-20230815112248257

2.5 静态代理存在的问题

1. 静态类文件数量过多，不利于项目管理
   UserServiceImpl  UserServiceProxy
   OrderServiceImpl OrderServiceProxy
2. 额外功能维护性差
   代理类中 额外功能修改复杂(麻烦)

2. Spring的动态代理开发

2.1 Spring动态代理的概念

概念：通过代理类为原始类(目标类)增加额外功能,代理类由Spring动态生成。
好处：利于原始类(目标类)的维护

2.2 搭建开发环境

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.1.14.RELEASE</version>
</dependency>

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjrt</artifactId>
  <version>1.8.8</version>
</dependency>

<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.3</version>
</dependency>

2.3 Spring动态代理的开发步骤

1. 创建原始对象(目标对象)

public class UserServiceImpl implements UserService{
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}
<bean id="userServiceImpl" class="com.Leo.dynamic.service.impl.UserServiceImpl"/>

2. 定义额外功能

实现MethodBeforeAdvice接口

public class Before implements MethodBeforeAdvice {
	//作用：给原始方法添加额外功能
    //注意：会在原始方法运行之前运行此方法
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("-----method before advice log------");
    }
}
<bean id="before" class="com.Leo.dynamic.service.Before"/>

3. 定义切入点

1. 切入点：额外功能加入的位置

2. 目的：由程序员根据自己的需要，决定额外功能加入给那个原始方法
register()
login()

简单的测试：所有方法都做为切入点，都加入额外的功能。
<aop:config>
   <aop:pointcut id="pc" expression="execution(* *(..))"/>
</aop:config>

4. 组装

<!-- 组装切入点与额外功能 -->
<aop:advisor advice-ref="before" pointcut-ref="pc"/>

5. 测试调用

目的：获得Spring工厂创建的动态代理对象，并进行调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
注意：
   1. Spring的工厂通过	原始对象的id值获得的是代理对象
   2. 获得代理对象后，可以通过声明接口类型，进行对象的存储
   
UserService userService=(UserService)ctx.getBean("userServiceImpl");

userService.login("","");
userService.register(new User());

控制台打印： 可以发现在日志之前输入了

image-20230815114453445

2.4 动态代理细节分析

4.1 Spring创建的动态代理类在哪里？

Spring框架在运行时，通过动态字节码技术，在JVM创建的，运行在JVM内部，等程序结束后就消失了。

什么叫动态字节码技术:通过第三方动态字节码框架，在JVM中创建对应类的字节码，进而创建对象，当虚拟机结束，动态字节码跟着消失。

结论：动态代理不需要定义类文件，都是JVM运行过程中动态创建的，所以不会造成静态代理，类文件数量过多，影响项目管理的问题。

image-20200423165547079

4.2 动态代理编程简化代理的开发

在额外功能不改变的前提下，创建其他目标类（原始类）的代理对象时，只需要指定原始(目标)对象即可。

3. Spring动态代理详解

3.1 额外功能的详解

  • MethodBeforeAdvice分析

    作用：原始方法执行之前，运行额外功能。

    public class Before implements MethodBeforeAdvice {
    /**
     * 作用：给原始方法添加额外功能
     * 注意：会在原始方法运行之前运行此方法
     * @param method 原始方法 login() register() ...
     * @param objects 原始方法的参数列表 name password ...
     * @param o 原始对象 UserServiceImpl OrderServiceImpl
     * @throws Throwable 抛出的异常
     */
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("---- MethodBeforeAdvice  log... ----");
    }
}

实战：需要时才用，可能都会用到，也有可能都不用。

  • MethodInterceptor(方法拦截器)

    MethodInterceptor接口：额外功能可定义在原始方法执行 前、后、前和后。

    public class Around implements MethodInterceptor {
    /**
     * @param invocation 封装了原始方法 invocation.proceed()表示原始方法的运行
     * @return 原始方法的返回值
     * @throws Throwable 可能抛出的异常
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("------ 额外功能 log -----");
		//原始方法的执行
        Object ret = invocation.proceed();
        //返回原始方法的返回值
        return ret;
    }
}

额外功能运行在原始方法执行之后

  public Object invoke(MethodInvocation invocation) throws Throwable {
    Object ret = invocation.proceed();
    System.out.println("-----额外功能运行在原始方法执行之后----");
  
    return ret;
  }

额外功能运行在原始方法执行之前和之后（实战：事务需要在之前和之后都运行）

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
  System.out.println("-----额外功能运行在原始方法执行之前----");
  Object ret = invocation.proceed();
  System.out.println("-----额外功能运行在原始方法执行之后----");

  return ret;
}

额外功能运行在原始方法抛出异常时

  @Override
public Object invoke(MethodInvocation invocation) throws Throwable {
  
    Object ret = null;
    try {
      ret = invocation.proceed();
    } catch (Throwable throwable) {
      System.out.println("-----原始方法抛出异常 执行的额外功能 ---- ");
      throwable.printStackTrace();
    }
  
    return ret;
  }

MethodInterceptor可以影响原始方法的返回值

@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
 System.out.println("------log-----");
   Object ret = invocation.proceed();
   //拿到原始方法的返回值后进行一些操作就会影响，直接返回就不影响
   return false;
}

3.2 切入点详解

切入点决定了额外功能加入的位置。

<aop:pointcut id="pc" expression="execution(* *(..))"/>
exection(* *(..)) ---> 匹配了所有方法    a  b  c 

1. execution()  切入点函数
2. * *(..)      切入点表达式

1. 切入点表达式

  • 方法切入点表达式：

    image-20200425105040237

    *  *(..)  --> 所有方法

* ---> 修饰符 返回值
* ---> 方法名
()---> 参数表
..---> 对于参数没有要求 (0个或多个)

举例：

  # 定义login方法作为切入点
  * login(..)
  
  # 定义register作为切入点
  * register(..)
  
  # 定义名字为login且有两个字符串类型参数的方法 作为切入点
  * login(String,String)
  
  # 注意：非java.lang包中的类型，必须要写全限定名
  * register(com.Leo.proxy.User)
  
  # ..可以和具体的参数类型连用(至少有一个参数是String类型)
  * login(String,..)
  
  # 精准方法切入点限定
  # 修饰符 返回值    包.类.方法(参数)
  
      *             com.yuziayn.proxy.UserServiceImpl.login(..)
      *             com.Leo.proxy.UserServiceImpl.login(String,String)

  • 类切入点表达式：

    指定特定的类作为切入点，即这个类中所有的方法都会加上额外功能。

    举例：

    # 类中的所有方法都加入额外功能 
* com.Leo.proxy.UserServiceImpl.*(..)

# 忽略包
# 1. 类只在一级包下  com.UserServiceImpl
* *.UserServiceImpl.*(..)

# 2. 类可在多级包下  com.Leo.proxy.UserServiceImpl
* *..UserServiceImpl.*(..)

  • 包切入点表达式：

    指定包作为切入点，即这个包中的所有类及其方法都会加入额外的功能。

    举例：

    # proxy包作为切入点，即proxy包下所有类中的所有方法都会加入额外功能，但是不包括其子包中的类！
* com.Leo.proxy.*.*(..)

# 当前包及其子包都生效
* com.Leo.proxy..*.*(..)

2 切入点函数

作用：用于执行切入点表达式。

  1. execution()

    最为重要的切入点函数，功能最全！
用于执行：方法切入点表达式、类切入点表达式、包切入点表达式 

弊端：execution执行切入点表达式 ，书写麻烦
     execution(* com.Leo.proxy..*.*(..))
     
注意：其他的切入点函数 只是简化execution书写复杂度，功能上完全一致

  2. args()

    # 作用：用于函数(方法)参数的匹配

# 举例：方法参数必须得是2个字符串类型的参数
	execution(* *(String,String))
	等价于：
	args(String,String)

  3. within()

    # 作用：用于进行类、包切入点表达式的匹配
# 举例：
# UserServiceImpl类作为切入点：
	execution(* *..UserServiceImpl.*(..))

	within(*..UserServiceImpl)
# proxy包作为切入点：
	execution(* com.Leo.proxy..*.*(..))
	
	within(com.yuziayan.proxy..*)

  4. @annotation()

    <!-- 作用：为具有特殊注解的方法加入额外功能 -->

<aop:pointcut id="" expression="@annotation(com.baizhiedu.Log)"/>

  5. 切入点函数间的逻辑运算：

    目的：整合多个切入点函数一起配合工作，进而完成更为复杂的需求。

    • and 与操作（同时满足）

      # 案例：方法名为login，同时有2个字符串类型的参数：
	execution(* login(String,String))

	execution(* login(..)) and args(String,String)

# 注意：与操作不能用于同种类型的切入点函数 
# 错误案例：register方法 和 login方法作为切入点（不能用and，而用or！）
	execution(* login(..)) and execution(* register(..))
# 上面的语句会发生错误，因为其实际表达的含义是方法名为login同时方法名为register，显然有悖逻辑，此时应该用到的是 or

  • or 或操作（满足一种即可）

       # 案例：register方法 和 login方法作为切入点 
   	execution(* login(..)) or  execution(* register(..))

4. AOP编程

4.1 AOP概念

# AOP (Aspect Oriented Programing)   面向切面编程 = Spring动态代理开发
# 以切面为基本单位的程序开发，通过切面间的彼此协同，相互调用，完成程序的构建
# 切面 = 切入点 + 额外功能

# OOP (Object Oriented Programing)   面向对象编程 Java
# 以对象为基本单位的程序开发，通过对象间的彼此协同，相互调用，完成程序的构建

# POP (Procedure Oriented Programing) 面向过程(方法、函数)编程 C 
# 以过程为基本单位的程序开发，通过过程间的彼此协同，相互调用，完成程序的构建

# AOP的概念：
     本质就是Spring的动态代理开发，通过代理类为原始类增加额外功能。
     好处：利于原始类的维护
# 注意：AOP编程不可能取代OOP，而是OOP编程的补充。

4.2 AOP编程的开发步骤

  1. 原始对象
  2. 额外功能 (MethodInterceptor)
  3. 切入点
  4. 组装切面 (额外功能+切入点)

4.3 切面的名词解释

切面 = 切入点 + 额外功能 

几何学
   面 = 点 + 相同的性质

image-20230529150312064

5. AOP的底层实现原理

5.1 核心问题

  • AOP如何创建动态代理类？(动态字节码技术)
  • Spring工厂如何加工创建代理对象？通过原始对象的id值，获得的是代理对象。

5.2 动态代理类的创建

1. JDK的动态代理

  • Proxy.newProxyInstance()方法参数详解:

    image-20200428175248912

image-20200428175316276

  • 编码：

    public class TestJDKProxy {
    public static void main(String[] args) {
        //1.创建原始对象
        //注意：由于后面匿名子类的方法中用到了userService，所以应该用final修饰
        //     而JDK1.8以后默认加了final，不需要手动加
        UserService userService = new UserServiceImpl();

        //2.JDK创建代理对象
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----------- JDKProxy log -----------");\
                //目标方法运行：
                Object ret = method.invoke(userService, args);
                return ret;
            }
        };

        UserService userServiceProxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(),handler);

        userServiceProxy.login("Leo", "123456");
        userServiceProxy.register(new User());

    }
}

2. CGlib的动态代理

  • 原理：通过父子继承关系创建代理对象。原始类作为父类，代理类作为子类，这样既可以保证2者方法一致，同时在代理类中提供新的实现(额外功能+原始方法)

image-20200429111709226

  • CGlib编码：

    package com.Leo.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class TestCGlibProxy {
    public static void main(String[] args) {
        //1.创建原始对象
        UserServiceImpl userService = new UserServiceImpl();

        //2.通过CGlib创建代理对象
        //  2.1 创建Enhancer
        Enhancer enhancer = new Enhancer();
        //  2.2 设置借用类加载器
        enhancer.setClassLoader(TestCGlibProxy.class.getClassLoader());
        //  2.3 设置父类（目标类）
        enhancer.setSuperclass(userService.getClass());
        //  2.4 设置回调，额外功能写在里面
        enhancer.setCallback(new MethodInterceptor() {
            //相当于 InvocationHandler --> invoke()
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //额外功能：
                System.out.println("========= CGlibProxy log ========");
                //目标方法执行：
                Object ret = method.invoke(userService, objects);
                return ret;
            }
        });
        //  2.5 通过Enhancer对象创建代理
        UserServiceImpl service = (UserServiceImpl) enhancer.create();

        //测试：
        service.register();
        service.login();

    }
}

3. 总结

1. JDK动态代理   Proxy.newProxyInstance()  
# 通过目标类实现的接口创建代理类 
2. Cglib动态代理 Enhancer                  
# 通过继承目标类创建代理类

5.3 Spring工厂如何返回代理对象

  • 思路分析：

image-20200430113353205

  • 编码模拟：

    public class ProxyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        InvocationHandler invocation = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("----------- 模拟Spring返回代理对象的方式 log -----------");

                Object ret = method.invoke(bean, args);

                return ret;
            }
        };

        return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), invocation);
    }
}

      <!-- 1.配置原始对象 -->
  <bean id="userService" class="com.Leo.factory.UserServiceImpl"></bean>
  <!-- 2.配置自己模拟的ProxyBeanPostProcessor -->
  <bean id="proxyBeanPostProcessor" class="com.Leo.factory.ProxyBeanPostProcessor"/>

6. 基于注解的AOP编程

6.1 开发步骤：

  1. 原始对象

  2. 额外功能

  3. 切入点

  4. 组装切面

    /**
 * 声明切面类     @Aspect
 * 定义额外功能   @Around
 * 定义切入点     @Around("execution(* login(..))")
 *
 */
@Aspect
public class MyAspect {

    @Around("execution(* login(..))")//组装了切入点和额外功能
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //额外功能：
        System.out.println("--------- 基于注解的AOP编程 log --------");
        //原始方法执行：
        Object ret = joinPoint.proceed();

        return ret;
    }
}

       <!-- 原始对象 -->
   <bean id="userService" class="com.Leo.aspect.UserServiceImpl"></bean>
   
   <!-- 切面 -->
   <bean id="myAspect" class="com.Leo.aspect.MyAspect"/>
   
   <!-- 开启基于注解的AOP编程 -->
   <aop:aspectj-autoproxy/>

6.2 细节分析：

  • 切入点复用：

    @Aspect
public class MyAspect {

    /**
     * 切入点复用：定义一个函数，加上@Pointcut注解，通过该注解的value定义切入点表达式，以后可以复用。
     */
    @Pointcut("execution(* login(..))")
    public void myPointcut(){}

    @Around("myPointcut()")//组装了切入点和额外功能
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        //额外功能：
        System.out.println("--------- 基于注解的AOP编程 log --------");
        //原始方法执行：
        Object ret = joinPoint.proceed();

        return ret;
    }


    @Around("myPointcut()")
    public Object around1(ProceedingJoinPoint joinPoint) throws Throwable {
        //额外功能：
        System.out.println("--------- 基于注解的AOP编程 tx --------");
        //原始方法执行：
        Object ret = joinPoint.proceed();
        return ret;
    }

}

  • 动态代理的创建方式：

    AOP底层实现  2种代理创建方式
  1.  JDK   通过实现接口，创建代理对象
  2.  Cglib 通过继承目标类，创建代理对象
  
  默认情况 AOP编程 底层应用JDK动态代理创建方式 
  如果要切换Cglib
       1. 基于注解AOP开发
          <aop:aspectj-autoproxy proxy-target-class="true" />
       2. 传统的AOP开发
          <aop:config proxy-target-class="true">
          </aop>

7. AOP开发中的一个坑

坑：在同一个业务类中，业务方法间相互调用时，只有最外层的方法,加入了额外功能(内部的方法，通过普通的方式调用，运行的都是原始方法)。如果想让内层的方法也调用代理对象的方法，就要实现AppicationContextAware获得工厂，进而获得代理对象。

public class UserServiceImpl implements UserService, ApplicationContextAware {
    private ApplicationContext ctx;


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
              this.ctx = applicationContext;
    }

    @Log
    @Override
    public void register(User user) {
        System.out.println("UserServiceImpl.register 业务运算 + DAO ");
        //throw new RuntimeException("测试异常");

        //调用的是原始对象的login方法 ---> 核心功能
        /*
            设计目的：代理对象的login方法 --->  额外功能+核心功能
            ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext2.xml");
            UserService userService = (UserService) ctx.getBean("userService");
            userService.login();

            Spring工厂重量级资源 一个应用中 应该只创建一个工厂
         */

        UserService userService = (UserService) ctx.getBean("userService");
        userService.login("Leo", "123456");
    }

    @Override
    public boolean login(String name, String password) {
        System.out.println("UserServiceImpl.login");
        return true;
    }
}

8. AOP阶段知识总结

AOP 总结

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/78743.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

国企的大数据岗位方向的分析

国企的大数据岗位方向的分析

现如今大数据已无所不在&#xff0c;并且正被越来越广泛的被应用到历史、政治、科学、经济、商业甚至渗透到我们生活的方方面面中&#xff0c;获取的渠道也越来越便利。 今天我们就来聊一聊“大屏应用”&#xff0c;说到大屏就一定要聊到数据可视化&#xff0c;现如今&#xf…
阅读更多...
eclipse 导入项目js报错问题

eclipse 导入项目js报错问题

eclipse 导入项目后会出现项目中的js文件报错&#xff08;红叉&#xff09;&#xff0c;如下图所示&#xff0c;有时候报错的文件很多&#xff0c;需要集中处理。 解决办法&#xff1a; 右键项目名称》Properties》MyEclipse》JavaScript》Include Path&#xff0c;在右侧选择“…
阅读更多...
linux 文件权限识别及其修改

linux 文件权限识别及其修改

一、文件权限认识 在 Linux 系统中&#xff0c;一切皆文件&#xff0c;目录也是一种文件形式叫目录文件&#xff0c;它们的属性主要包含&#xff1a;索引节点(inode)&#xff0c;类型、权限属性、链接数、所归属的用户和用户组、最近修改时间等内容。 如下为根目录下目录&…
阅读更多...
基于OpenCV的人脸识别和模型训练系统（万字详解）

基于OpenCV的人脸识别和模型训练系统（万字详解）

前言 我们身边的人脸识别有车站检票&#xff0c;监控人脸&#xff0c;无人超市&#xff0c;支付宝人脸支付&#xff0c;上班打卡&#xff0c;人脸解锁手机。 人脸检测是人脸识别系统组成的关键部分之一&#xff0c;其目的是检测出任意给定图片中的包含的一个或多个人脸&#…
阅读更多...
网络通信原理IP头部格式（第四十二课）

网络通信原理IP头部格式（第四十二课）

字段作用解析：1）版本: 指的IP地址的版本 （IPv4 或 IPV6）2）首部长度: 次数据包的首部长度一共是多少，没有加可选项3）优先级与服务类型:表示****数据包是否需要优选传递4）总长度: 表示的是整个数据包的大小，也就****是首部+数据5）标识符、标志、段偏移量:的作用将拆开的…
阅读更多...
ts与vue

ts与vue

ts与Vue 如果你已经学习了typeScript,但不知道如何在vue项目中使用&#xff0c;那么这篇文章将会很适合你。参考千峰教育 kerwin视频 1.会自动推导&#xff0c;隐士推导。提示 类型系统。 独立模块。 isolatedModules选项&#xff1a;是否配置为独立的模块。 减少报错 let …
阅读更多...
Springboot项目启动后按顺序加载自定义类 (demo)

Springboot项目启动后按顺序加载自定义类 (demo)

1. 实现ApplicationRunner接口, 重写run方法 import lombok.extern.slf4j.Slf4j; import org.springframework.boot.ApplicationArguments; import org.springframework.boot.ApplicationRunner; import org.springframework.core.annotation.Order; import org.springframewor…
阅读更多...
IDEA项目实践——JavaWeb简介以及Servlet编程实战

IDEA项目实践——JavaWeb简介以及Servlet编程实战

系列文章目录 IDEA项目实践——创建Java项目以及创建Maven项目案例、使用数据库连接池创建项目简介 IDEWA项目实践——mybatis的一些基本原理以及案例 IDEA项目实践——动态SQL、关系映射、注解开发 IDEA项目实践——Spring框架简介，以及IOC注解 IDEA项目实践——Spring当…
阅读更多...
mysql 03.查询（重点）

mysql 03.查询（重点）

先准备测试数据&#xff0c;代码如下&#xff1a; -- 创建数据库 DROP DATABASE IF EXISTS mydb; CREATE DATABASE mydb; USE mydb;-- 创建student表 CREATE TABLE student (sid CHAR(6),sname VARCHAR(50),age INT,gender VARCHAR(50) DEFAULT male );-- 向student表插入数据…
阅读更多...
好用的安卓手机投屏到mac分享

好用的安卓手机投屏到mac分享

工具推荐&#xff1a;scrcpy github地址&#xff1a;https://github.com/Genymobile/scrcpy/tree/master mac使用方式 安装环境&#xff0c;打开terminal&#xff0c;执行以下命令&#xff0c;没有brew的先安装brew brew install scrcpy brew install android-platform-too…
阅读更多...
运营商三要素 API：构建安全高效的身份验证系统

运营商三要素 API：构建安全高效的身份验证系统

当今数字化的世界中&#xff0c;身份验证是各行各业中至关重要的一环。为了保护用户的隐私和数据安全&#xff0c;企业需要寻求一种既安全可靠又高效便捷的身份验证方式。运营商三要素 API 应运而生&#xff0c;为构建安全高效的身份验证系统提供了有力的解决方案。 运营商三要…
阅读更多...
【卷积神经网络】卷积，池化，全连接

【卷积神经网络】卷积，池化，全连接

随着计算机硬件的升级与性能的提高&#xff0c;运算量已不再是阻碍深度学习发展的难题。卷积神经网络&#xff08;Convolution Neural Network&#xff0c;CNN&#xff09;是深度学习中一项代表性的工作&#xff0c;CNN 是受人脑对图像的理解过程启发而提出的模型&#xff0c;其…
阅读更多...
【C++学习手札】一文带你认识C++虚函数（内层剖析）

【C++学习手札】一文带你认识C++虚函数（内层剖析）

食用指南&#xff1a;本文在有C基础的情况下食用更佳 &#x1f340;本文前置知识&#xff1a; C初识继承 ♈️今日夜电波&#xff1a;No title —REOL 1:02 ━━━━━━️&#x1f49f;──────── 4:03 …
阅读更多...
微服务中间件--微服务保护

微服务中间件--微服务保护

微服务保护 微服务保护a.sentinelb.sentinel限流规则1) 流控模式1.a) 关联模式1.b) 链路模式 2) 流控效果2.a) 预热模式2.b) 排队等待 3) 热点参数限流 c.隔离和降级1) Feign整合Sentinel2) 线程隔离2.a) 线程隔离&#xff08;舱壁模式&#xff09; 3) 熔断降级3.a) 熔断策略-慢…
阅读更多...
基于Servlet实现的管理系统（包含服务器源码+数据库）

基于Servlet实现的管理系统（包含服务器源码+数据库）

资料下载链接 介绍 基于Servlet框架的管理系统 简洁版 &#xff1b; 实现 登录 、 注册 、 增 、 删 、 改 、 查 &#xff1b; 可继续完善增加前端、校验、其他功能等&#xff1b; 可作为 Servlet项目 开发练习基础模型&#xff1b; 课程设计 、 毕业设计 开发基础&…
阅读更多...
java-垃圾回收与算法

java-垃圾回收与算法

垃圾回收与算法 1. 如何确定垃圾 1. 引用计数法 在 Java 中&#xff0c;引用和对象是有关联的。如果要操作对象则必须用引用进行。因此&#xff0c;很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。简单说&#xff0c;即一个对象如果没有任何与之关联的引用&…
阅读更多...
基于YOLOv5n/s/m不同参数量级模型开发构建茶叶嫩芽检测识别模型，使用pruning剪枝技术来对模型进行轻量化处理，探索不同剪枝水平下模型性能影响【续】

基于YOLOv5n/s/m不同参数量级模型开发构建茶叶嫩芽检测识别模型，使用pruning剪枝技术来对模型进行轻量化处理，探索不同剪枝水平下模型性能影响【续】

这里主要是前一篇博文的后续内容&#xff0c;简单回顾一下&#xff1a;本文选取了n/s/m三款不同量级的模型来依次构建训练模型&#xff0c;所有的参数保持同样的设置&#xff0c;之后探索在不同剪枝处理操作下的性能影响。 在上一篇博文中保持30的剪枝程度得到的效果还是比较理…
阅读更多...
Qt平滑弹出页面

Qt平滑弹出页面

目标功能&#xff1a; (1)按下btn&#xff0c;弹出绿色页面。 (2)按下btn2,绿色页面隐藏。 (3)按下左边余下的区域&#xff0c;绿色页面也隐藏。 (4)平滑地显示和隐藏 效果&#xff1a; form.h #ifndef FORM_H #define FORM_H#include <QWidget>namespace Ui { class…
阅读更多...
如何将labelImg打包成exe

如何将labelImg打包成exe

最近整理一下数据标注这块的内容&#xff0c;在目标检测和目标分割里面用的最多的标注工具labelimg&#xff0c;labelme labelimg主要用于目标检测领域制作自己的数据集&#xff0c;如&#xff1a;YOLO系列目标检测模型 labelme主要用于图像分割领域制作自己的数据集&#xf…
阅读更多...
IDEA 设置为护眼的豆沙绿

IDEA 设置为护眼的豆沙绿

代码区域设置成护眼色 先打开 IDEA 的设置界面&#xff0c;然后按照下图按顺序店了设置就可以了 这个时候&#xff0c;可以看到&#xff0c;只有代码区域别成了护眼色&#xff0c;其他地方还是白的刺眼&#xff0c;我们来一个一个的解决掉 左侧的文件页修改为护眼色 还是先…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站