Spring系列 AOP实现过程

news2024/11/23 18:54:05

文章目录

  • 实现原理
    • EnableAspectJAutoProxy
    • AnnotationAwareAspectJAutoProxyCreator 代理创建过程
      • wrapIfNecessary
      • getAdvicesAndAdvisorsForBean
        • findCandidateAdvisors
        • findAdvisorsThatCanApply
      • createProxy
    • @AspectJ注解处理
    • 代理调用过程

实现原理

本文源码基于spring-aop-5.3.31版本，测试代码如下：

@Aspect
@Component
public class UserAspect {

    @Pointcut("execution(* org.example..*..UserService.*(..))")
    private void pointcut() {
    }

    @Around("pointcut()")
    public Object aroundUserServiceOperation(ProceedingJoinPoint pjp) throws Throwable {  //2
        long start = System.currentTimeMillis();
        Object retVal = pjp.proceed();
        long duration = System.currentTimeMillis() - start;
        System.out.printf("time for pointcut method is %d seconds%n", duration);
        return retVal;
    }
}

@Service
public class UserService {

    public String login(String username, String password) {
        return String.format(" %s login with password: %s\n", username, password);
    }
}

@RestController
@RequestMapping(value = "/api/user")
public class UserController {

    @Resource
    UserService userService;

    @PostMapping("/login")
    public String login(@RequestParam("username") String username, @RequestParam("password") String password) {
        return userService.login(username, password);
    }
}

启动类

@SpringBootApplication
@EnableAspectJAutoProxy
public class Main {
    public static void main(String[] args) {
        SpringApplication.run(Main.class, args);
    }
}

EnableAspectJAutoProxy

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {

	/**
	 * 指定代理方式是CGLIB还是基于接口的动态代理
	 */
	boolean proxyTargetClass() default false;

	/**
	 * 是否暴露代理对象，暴露可以通过AopContext拿到
	 */
	boolean exposeProxy() default false;
}

导入了这个AspectJAutoProxyRegistrar，实际上是一个ImportBeanDefinitionRegistrar实现。我们知道，@Import + ImportBeanDefinitionRegistrar结合使用的效果就是向容器中注入一些Bean。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	/**
	 * 注册, 配置AspectJ代理
	 */
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		// 这一步就是所有的注册过程
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

通过AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);可以看到

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
	return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
		BeanDefinitionRegistry registry, @Nullable Object source) {

	return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

@Nullable
private static BeanDefinition registerOrEscalateApcAsRequired(
		Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {

	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
	// AUTO_PROXY_CREATOR_BEAN_NAME
	// org.springframework.aop.config.internalAutoProxyCreator
	if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
		BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
		if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
			int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
			int requiredPriority = findPriorityForClass(cls);
			if (currentPriority < requiredPriority) {
				apcDefinition.setBeanClassName(cls.getName());
			}
		}
		return null;
	}

	RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
	beanDefinition.setSource(source);
	beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
	beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
	return beanDefinition;
}

从上面的内容来看，AspectJAutoProxyRegistrar的工作就是注册一个AspectJAutoProxyCreator的东西，默认是org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator，如果容器种已经有了一个名称为org.springframework.aop.config.internalAutoProxyCreator的Bean，那么会优先使用它，否则使用AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator 代理创建过程

AspectJAwareAdvisorAutoProxyCreator的子类，负责处理所有AspectJ注解，以及所有Spring的Advisor。所有AspectJ注解的类都会被自动识别
在这里插入图片描述
主要关注点，它是一个BeanPostProcessor

在这里插入图片描述
最终org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator找到了Bean的后置处理逻辑

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
	Object cacheKey = getCacheKey(beanClass, beanName);

	if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
		if (this.advisedBeans.containsKey(cacheKey)) {
			return null;
		}
		if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return null;
		}
	}

	// Create proxy here if we have a custom TargetSource.
	// Suppresses unnecessary default instantiation of the target bean:
	// The TargetSource will handle target instances in a custom fashion.
	TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
	if (targetSource != null) {
		if (StringUtils.hasLength(beanName)) {
			this.targetSourcedBeans.add(beanName);
		}
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
		Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
		this.proxyTypes.put(cacheKey, proxy.getClass());
		return proxy;
	}
	return null;
}

/**
 * Create a proxy with the configured interceptors if the bean is
 * identified as one to proxy by the subclass.
 * @see #getAdvicesAndAdvisorsForBean
 */
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
	// bean 就是被代理对象
	if (bean != null) {
		Object cacheKey = getCacheKey(bean.getClass(), beanName);
		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
			return wrapIfNecessary(bean, beanName, cacheKey);
		}
	}
	return bean;
}

代理是需要创建代理对象和被代理对象的

wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
	if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
		return bean;
	}
	if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
		return bean;
	}
	// 下面四个类不会被代理：Advice, Pointcut, Advisor, AopInfrastructureBean
	if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

	// Create proxy if we have advice.
	Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
	if (specificInterceptors != DO_NOT_PROXY) {
		this.advisedBeans.put(cacheKey, Boolean.TRUE);
		Object proxy = createProxy(
				bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
		this.proxyTypes.put(cacheKey, proxy.getClass());
		return proxy;
	}

	this.advisedBeans.put(cacheKey, Boolean.FALSE);
	return bean;
}

getAdvicesAndAdvisorsForBean

对于指定的Bean，获取可用的切面，如果没有切面，则无需生成代理

org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator实现了这个方法

@Override
protected Object[] getAdvicesAndAdvisorsForBean(
		Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

	List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
	if (advisors.isEmpty()) {
		return DO_NOT_PROXY;
	}
	return advisors.toArray();
}

protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
	// 获取所有的Advisor
	List<Advisor> candidateAdvisors = findCandidateAdvisors();
	// 找到与beanClass相关联的那些Advisor
	List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
	extendAdvisors(eligibleAdvisors);
	if (!eligibleAdvisors.isEmpty()) {
		eligibleAdvisors = sortAdvisors(eligibleAdvisors);
	}
	return eligibleAdvisors;
}
findCandidateAdvisors
/**
 * Find all candidate Advisors to use in auto-proxying.
 * @return the List of candidate Advisors
 */
protected List<Advisor> findCandidateAdvisors() {
	Assert.state(this.advisorRetrievalHelper != null, "No BeanFactoryAdvisorRetrievalHelper available");
	return this.advisorRetrievalHelper.findAdvisorBeans();
}

AnnotationAwareAspectJAutoProxyCreator中继承了此方法

@Override
protected List<Advisor> findCandidateAdvisors() {
	// Add all the Spring advisors found according to superclass rules.
	List<Advisor> advisors = super.findCandidateAdvisors();
	// Build Advisors for all AspectJ aspects in the bean factory.
	if (this.aspectJAdvisorsBuilder != null) {
		advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
	}
	return advisors;
}

切面的查找实际上委托给了BeanFactoryAdvisorRetrievalHelper和BeanFactoryAspectJAdvisorsBuilder这两个类来完成的

BeanFactoryAdvisorRetrievalHelper用于从BeanFactory中获取org.springframework.aop.Advisor接口的实现类，核心逻辑如下（省略了部分不重要的代码）

public List<Advisor> findAdvisorBeans() {
	// Determine list of advisor bean names, if not cached already.
	String[] advisorNames = this.cachedAdvisorBeanNames;
	if (advisorNames == null) {
		// 获取所有Advisor类型的Bean名称，同时缓存到 this.cachedAdvisorBeanNames
		advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
				this.beanFactory, Advisor.class, true, false);
		this.cachedAdvisorBeanNames = advisorNames;
	}
	if (advisorNames.length == 0) {
		return new ArrayList<>();
	}
	List<Advisor> advisors = new ArrayList<>();
	for (String name : advisorNames) {
		if (isEligibleBean(name)) {
			// 忽略正在创建的Bean
			if (this.beanFactory.isCurrentlyInCreation(name)) {
				// 记录日志
			} else {
				// ....
				advisors.add(this.beanFactory.getBean(name, Advisor.class));
				// ....
			}
		}
	}
	return advisors;
}

BeanFactoryAspectJAdvisorsBuilder

在项目启动的过程中，项目中的所有切面会被 AnnotationAwareAspectJAutoProxyCreator 解析，它会找到切面中的每一个通知以及通知对应的切点，拿这二者构建一个新的对象，这个对象就是 Advisor。最后将所有解析得到的增强器注入到容器中。

BeanFactoryAspectJAdvisorsBuilder这个类的操作是获取所有Advisor

创建代理

在这里插入图片描述

findAdvisorsThatCanApply

此方法的作用是找到目标类可用的Advisor列表

protected List<Advisor> findAdvisorsThatCanApply(
		List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
	ProxyCreationContext.setCurrentProxiedBeanName(beanName);
	try {
		return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
	} finally {
		ProxyCreationContext.setCurrentProxiedBeanName(null);
	}
}

判断Advisor和目标类是否匹配

  1. IntroductionAdvisor：使用ClassFilter类进行匹配
  2. PointcutAdvisor：使用Pointcut来进行匹配
public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
	if (advisor instanceof IntroductionAdvisor) {
		return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
	}
	else if (advisor instanceof PointcutAdvisor) {
		PointcutAdvisor pca = (PointcutAdvisor) advisor;
		return canApply(pca.getPointcut(), targetClass, hasIntroductions);
	}
	else {
		// It doesn't have a pointcut so we assume it applies.
		return true;
	}
}

在这里插入图片描述

PointCut类型的

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
	Assert.notNull(pc, "Pointcut must not be null");
	if (!pc.getClassFilter().matches(targetClass)) {
		return false;
	}

	MethodMatcher methodMatcher = pc.getMethodMatcher();
	if (methodMatcher == MethodMatcher.TRUE) {
		// No need to iterate the methods if we're matching any method anyway...
		return true;
	}
	// AspectJExpressionPointcut
	IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
	if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
		introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
	}

	Set<Class<?>> classes = new LinkedHashSet<>();
	if (!Proxy.isProxyClass(targetClass)) {
		classes.add(ClassUtils.getUserClass(targetClass));
	}
	classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

	for (Class<?> clazz : classes) {
		Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
		for (Method method : methods) {
			if (introductionAwareMethodMatcher != null ?
					introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
					methodMatcher.matches(method, targetClass)) {
				return true;
			}
		}
	}

	return false;
}

AspectJExpressionPointcut是一个MethodMatcher的实现，代表了使用AspectJ注解@Pointcut定义的一个切点，比如：

@Pointcut("execution(* org.example..*..UserService.*(..))")
private void pointcut() {
}

createProxy

找到Advisor之后下一步就是创建代理对象
在这里插入图片描述

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
		@Nullable Object[] specificInterceptors, TargetSource targetSource) {

	if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
		AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
	}

	ProxyFactory proxyFactory = new ProxyFactory();
	proxyFactory.copyFrom(this);

	if (proxyFactory.isProxyTargetClass()) {
		// Explicit handling of JDK proxy targets and lambdas (for introduction advice scenarios)
		if (Proxy.isProxyClass(beanClass) || ClassUtils.isLambdaClass(beanClass)) {
			// Must allow for introductions; can't just set interfaces to the proxy's interfaces only.
			for (Class<?> ifc : beanClass.getInterfaces()) {
				proxyFactory.addInterface(ifc);
			}
		}
	}
	else {
		// No proxyTargetClass flag enforced, let's apply our default checks...
		if (shouldProxyTargetClass(beanClass, beanName)) {
			proxyFactory.setProxyTargetClass(true);
		}
		else {
			evaluateProxyInterfaces(beanClass, proxyFactory);
		}
	}

	Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
	proxyFactory.addAdvisors(advisors);
	proxyFactory.setTargetSource(targetSource);
	customizeProxyFactory(proxyFactory);

	proxyFactory.setFrozen(this.freezeProxy);
	if (advisorsPreFiltered()) {
		proxyFactory.setPreFiltered(true);
	}

	// Use original ClassLoader if bean class not locally loaded in overriding class loader
	ClassLoader classLoader = getProxyClassLoader();
	if (classLoader instanceof SmartClassLoader && classLoader != beanClass.getClassLoader()) {
		classLoader = ((SmartClassLoader) classLoader).getOriginalClassLoader();
	}
	return proxyFactory.getProxy(classLoader);
}

@AspectJ注解处理

@Aspect注解表示一个AspectJ配置类，里面可以配置切点和切面，以及二者之间的关系

注意：@Aspect在Spring中没有专门定义一个组件去扫描它，因此需要其他额外的配置将@AspectJ配置的那个类放入Spring容器

  1. 加@Component注解

  2. 使用@ComponentScan注解

  3. 如果使用XML配置，可以使用context:component-scan，还需要配置<context:include-filter/> ，其中context:component-scan这个标签是扫描@Component、@Controller、@Service等这些注解的类，则把这些类注册为bean。它不扫描@Aspect注解的。所以需要在子标签添加 <context:include-filter type="annotation"expression=“org.aspectj.lang.annotation.Aspect”/>

代理调用过程

如果想跟踪Advice是如何执行的，以及Advice执行到被代理类方法执行的过程，该怎么办呢？
在这里插入图片描述

仅需要进行简单的设置，即可输出cglib以及jdk动态代理产生的class文件，然后工具查看生成的动态代理类

// 输出cglib动态代理产生的类
System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "D:\\class");
// 输出jdk动态代理产生的类
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");

基于CGlib的代理类命名方式为：被代理类类名 + $$EnhancerBySpringCGLIB$$ + 8个随机字符，例如：UserService$$EnhancerBySpringCGLIB$$efcfcced

在这里插入图片描述
使用jd-gui工具查看反编译的字节码，如下图所示
在这里插入图片描述
可以在里面找到login方法
在这里插入图片描述
下面将login方法调用的相关内容拿出来看看

import java.lang.reflect.Method;
import org.aopalliance.aop.Advice;
import org.springframework.aop.Advisor;
import org.springframework.aop.SpringProxy;
import org.springframework.aop.TargetClassAware;
import org.springframework.aop.TargetSource;
import org.springframework.aop.framework.Advised;
import org.springframework.aop.framework.AopConfigException;
import org.springframework.cglib.core.ReflectUtils;
import org.springframework.cglib.core.Signature;
import org.springframework.cglib.proxy.Callback;
import org.springframework.cglib.proxy.Dispatcher;
import org.springframework.cglib.proxy.Factory;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import org.springframework.cglib.proxy.NoOp;

public class UserService$$EnhancerBySpringCGLIB$$efcfcced 
		extends UserService implements SpringProxy, Advised, Factory {

	private MethodInterceptor CGLIB$CALLBACK_0;
	private static final MethodProxy CGLIB$login$0$Proxy;
	private static final Method CGLIB$login$0$Method;
	
	public final String login(String paramString1, String paramString2) {
	  if (this.CGLIB$CALLBACK_0 == null)
	    CGLIB$BIND_CALLBACKS(this); 
	  return (this.CGLIB$CALLBACK_0 != null) ? 
	  	(String)this.CGLIB$CALLBACK_0.intercept(this, 
	  			CGLIB$login$0$Method, new Object[] { 
	  				paramString1, paramString2 }, CGLIB$login$0$Proxy)
	   : super.login(paramString1, paramString2);
	}
}

MethodInterceptor是spring-core提供的一个接口

public interface MethodInterceptor extends Callback {
    Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable;
}

intercept(Object obj, Method method, Object[] args, MethodProxy proxy)是 MethodInterceptor 的核心方法。在方法被调用时，Spring 会调用此方法，传递如下参数：

  1. obj：被代理的目标对象，即UserService
  2. method：被调用的方法，即login方法
  3. args：方法的参数
  4. proxy：用于调用目标方法的 MethodProxy 对象

现在只知道CGLIB$CALLBACK_0是一个MethodInterceptor，但到底是哪个实现呢，我们可以通过Debug查看，如下图所示，可以看到它的实际类型是org.springframework.aop.framework.CglibAopProxy.DynamicAdvisedInterceptor
在这里插入图片描述

@Override
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
	Object oldProxy = null;
	boolean setProxyContext = false;
	Object target = null;
	// this.advised -> ProxyFactory
	TargetSource targetSource = this.advised.getTargetSource();
	try {
		if (this.advised.exposeProxy) {
			// Make invocation available if necessary.
			oldProxy = AopContext.setCurrentProxy(proxy);
			setProxyContext = true;
		}
		// Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
		target = targetSource.getTarget();
		Class<?> targetClass = (target != null ? target.getClass() : null);
		// 获取拦截器链，即@Around, @Before等修饰的方法
		List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
		Object retVal;
		// Check whether we only have one InvokerInterceptor: that is,
		// no real advice, but just reflective invocation of the target.
		if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {
			// We can skip creating a MethodInvocation: just invoke the target directly.
			// Note that the final invoker must be an InvokerInterceptor, so we know
			// it does nothing but a reflective operation on the target, and no hot
			// swapping or fancy proxying.
			Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
			retVal = invokeMethod(target, method, argsToUse, methodProxy);
		}
		else {
			// We need to create a method invocation...
			retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
		}
		retVal = processReturnType(proxy, target, method, retVal);
		return retVal;
	}
	finally {
		if (target != null && !targetSource.isStatic()) {
			targetSource.releaseTarget(target);
		}
		if (setProxyContext) {
			// Restore old proxy.
			AopContext.setCurrentProxy(oldProxy);
		}
	}
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Arweave的经济学模型

Arweave的经济学模型

一、存储成本和挖矿奖励 1.1 永久数据存储的成本 由于 Arweave 的核心功能是为其用户提供永久存储&#xff0c;因此必须定义这种存储的定价机制。 作为计算永久存储一份数据的成本的前提&#xff0c;我们必须首先定义单个时间段的数据存储成本&#xff1a; 自数字数据存储技…
阅读更多...
算法-数组笔记

算法-数组笔记

二分搜索 . - 力扣&#xff08;LeetCode&#xff09; 使用场景 前提是数组为有序数组&#xff0c;同时题目还强调数组中无重复元素。 因为一旦有重复元素&#xff0c;使用二分查找法返回的元素下标可能不是唯一的&#xff0c;这些都是使用二分法的前提条件&#xff0c;当大…
阅读更多...
【Ubuntu】git

【Ubuntu】git

文章目录 1.配置SSH key2. 基础知识操作命令1分支branch 如果对git命令使用不熟悉&#xff0c;推荐一个非常棒的git在线练习工具 Learn Git Branching。 https://m.runoob.com/git/git-basic-operations.html 1.配置SSH key ssh-keygen -t rsa -C "YOUR EMAIL"完成…
阅读更多...
深入解析 Java 虚拟机：内存区域、类加载与垃圾回收机制

深入解析 Java 虚拟机：内存区域、类加载与垃圾回收机制

我的主页&#xff1a;2的n次方_ 1. JVM 内存区域划分 程序计数器&#xff08;空间比较小&#xff09;。保存了下一条要执行的指令的地址&#xff08;指向元数据区指令的地址&#xff09;堆。JVM 最大的空间&#xff0c;new 出来的对象都在堆上栈。函数中的局部变量&#x…
阅读更多...
Linux相关概念和重要知识点（10）（进程优先级、进程切换）

Linux相关概念和重要知识点（10）（进程优先级、进程切换）

1.进程优先级 &#xff08;1&#xff09;为什么要有进程优先级&#xff1f; 优先级的本质是获得某种资源的先后顺序&#xff0c;如排队买票这件事上排队的本质是在确认优先级&#xff0c;售票窗口就是要竞争的资源。为什么要有优先级&#xff1f;本质就是目标资源比较少&…
阅读更多...
VS2022 Git功能的使用

VS2022 Git功能的使用

前言 博主最近在学校接触了团队开发的概念&#xff0c;最近也系统性学习了c语言&#xff0c;也是从0开始摸索&#xff0c;一开始博主在推送代码的时候使用的是git bash 后来发现VS2022有Git相关功能&#xff0c;但是博主在网上没有找到通俗易懂适合小白的配置教程&#xff0c;…
阅读更多...
HarmonyOS应用六之应用程序进阶一

HarmonyOS应用六之应用程序进阶一

目录&#xff1a; 1、UIAbility的冷启动和UIAbility热启动2、静态资源和动态资源的访问3、页面跳转3.1、页面返回跳转 4、HAR的ArkUI组件、接口、资源&#xff0c;供其他应用或当前应用的其他模块引用4.1、导出HAR的ArkUI组件4.2、引用HAR的ArkUI组件 5、循环渲染6、状态管理最…
阅读更多...
【生成模型】学习笔记

【生成模型】学习笔记

生成模型 生成模型概述&#xff08;通俗解释&#xff09; 生成的核心是生成抽象化的内容&#xff0c;利用已有的内容生成没有的/现实未发生的内容。这个过程类似于人类发挥想象力的过程。 生成模型的应用场景非常广泛&#xff0c;可以应用于艺术表达&#xff0c;如画的生成、…
阅读更多...
前端规范工程-2：JS代码规范（Prettier + ESLint）

前端规范工程-2：JS代码规范（Prettier + ESLint）

Prettier 和 ESLint 是两个在现代 JavaScript 开发中广泛使用的工具&#xff0c;它们结合起来可以提供以下作用和优势&#xff1a; 代码格式化和风格统一&#xff1a; Prettier 是一个代码格式化工具&#xff0c;能够自动化地处理代码的缩进、空格、换行等格式问题&#xff0c;…
阅读更多...
【PHP陪玩系统源码】游戏陪玩系统app，陪玩小程序优势

【PHP陪玩系统源码】游戏陪玩系统app，陪玩小程序优势

陪玩系统开发运营级别陪玩成品搭建 支持二开源码交付&#xff0c;游戏开黑陪玩系统: 多客陪玩系统&#xff0c;游戏开黑陪玩&#xff0c;线下搭子&#xff0c;开黑陪玩系统 前端uniapp后端php&#xff0c;数据库MySQL 1、长时间的陪玩APP源码开发经验&#xff0c;始终坚持从客户…
阅读更多...
JAVA中的集合有哪些？？？

JAVA中的集合有哪些？？？

引言; Java 中的集合类主要分为两大类:Collection 接口和 Map 接口。前者是存储对象的集合类&#xff0c;后者存储的是键值对(key-value)。 &#xff08;这是在IntelliJ IDEA中使用Diagram功能来操作绘制的UML类图&#xff09; Set&#xff08;实现类&#xff09; HashSet: 基…
阅读更多...
安全中心 (SOC) 与 网络运营中心 (NOC)

安全中心 (SOC) 与 网络运营中心 (NOC)

NOC 和 SOC 之间的区别 网络运营中心 (NOC) 负责维护公司计算机系统的技术基础设施&#xff0c;而安全运营中心 (SOC) 则负责保护组织免受网络威胁。 NOC 专注于防止自然灾害、停电和互联网中断等自然原因造成的网络干扰&#xff0c;而 SOC 则从事监控、管理和保护。 NOC 提…
阅读更多...
《Windows PE》3.2.3 NT头-扩展头

《Windows PE》3.2.3 NT头-扩展头

■扩展头&#xff08;可选标头仅限映像文件&#xff09; OptionalHeader字段描述了可执行文件的更多细节和布局信息&#xff0c;如图像基址、入口点、数据目录、节表等。它的具体结构取决于文件的机器架构&#xff0c;可以是IMAGE_OPTIONAL_HEADER32&#xff08;32位&#xff…
阅读更多...
简单线性回归分析-基于R语言

简单线性回归分析-基于R语言

本题中&#xff0c;在不含截距的简单线性回归中&#xff0c;用零假设对统计量进行假设检验。首先&#xff0c;我们使用下面方法生成预测变量x和响应变量y。 set.seed(1) x <- rnorm(100) y <- 2*xrnorm(100) &#xff08;a&#xff09;不含截距的线性回归模型构建。 &…
阅读更多...
如何选择合适的跨境网络专线？

如何选择合适的跨境网络专线？

选择合适的跨境网络专线对于保障企业的国际业务顺畅运行至关重要。以下是一些选择跨境网络专线时可以参考的关键点&#xff1a; 服务商的信誉和经验&#xff1a;首先考察服务商的市场声誉和行业经验。一个好的服务商应该拥有良好的客户评价和成功案例&#xff0c;这表明他们有能…
阅读更多...
心觉：如何抓住宇宙送来的运气和机会？

心觉：如何抓住宇宙送来的运气和机会？

Hi&#xff0c;我是心觉&#xff0c;与你一起玩转潜意识、脑波音乐和吸引力法则&#xff0c;轻松掌控自己的人生&#xff01; 挑战每日一省写作186/1000天 赚钱需要系统学习吗 你会发现生活中没什么学历&#xff0c;知道的也没你多&#xff0c;行动力也不一定有你强&#x…
阅读更多...
【Orange Pi 5嵌入式应用编程】-用户空间GPIO控制

【Orange Pi 5嵌入式应用编程】-用户空间GPIO控制

用户空间GPIO控制 文章目录 用户空间GPIO控制1、嵌入式Linux的GPIO子系统介绍1.1 sysfs文件访问GPIO1.2 通过字符设备访问GPIO1.3 库与工具2、RK3588的GPIO介绍3、用户空间操作GPIO编程3.1 硬件准备3.2 通过libgpio操作GPIO3.2.1 GPIO输出3.2.3 GPIO输入3.2.3 边沿事件检测(中断…
阅读更多...
Tomcat监控与调优：比Tomcat Manager更加强大的Psi-Probe

Tomcat监控与调优：比Tomcat Manager更加强大的Psi-Probe

这是一款 Tomcat 管理和监控工具&#xff0c;前身是 Lambda Probe。由于 Lambda Probe 2006不再更新&#xff0c;所以 PSI Probe 算是对其的一个 Fork 版本并一直更新至今。 Probe psi-probe是在相同的开源许可证(GPLV2)下分发的社区驱动的 Lambda Probe &#xff0c;psi-pro…
阅读更多...
笔记整理—linux进程部分（4）进程状态与守护进程

笔记整理—linux进程部分（4）进程状态与守护进程

进程的几种重要状态&#xff0c;就绪态&#xff1b;运行态&#xff1b;僵尸态&#xff1b;等待态&#xff08;浅度睡眠、深度睡眠&#xff09;&#xff1b;停止态。 就单核CPU而言&#xff0c;在同一时间只能运行一个进程&#xff0c;但实际上要运行的进程不止一个&#xff0c;…
阅读更多...
手机实时提取SIM卡打电话的信令声音-(题外、插播一条广告)

手机实时提取SIM卡打电话的信令声音-(题外、插播一条广告)

手机实时提取SIM卡打电话的信令声音-(题外、插播一条广告) 前言 在去年的差不多这个时候&#xff0c;我们做了一遍外置配件的选型&#xff0c;筛选过滤了一批USB蓝牙配件和type-c转usb的模块。详情可参考《外置配件的电商价格和下载链接的选型.docx》一文&#xff1a;蓝牙电话…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023