标签：执行 拦截器 Spring beanName bean spring 注解 源代码 public
AOP底层实现动态代理
1、导入spring-aop包依赖
<!--aopV1-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<scope>test</scope>
</dependency>
<!--aopV2-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
</dependency>2、在配置类加入注解
@EnableAspectJAutoProxy//启用AOP切面（开启注解版的AOP功能）
3、@Aspect
在切面类上加入@Aspect表示这是一个切面
4、切面配置
spring官方文档（https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-introduction-defn）
-
/*
-
标识这个方法是个前置通知, 切点表达式表示执行任意类的任意方法.
-
第一个 * 代表匹配任意修饰符及任意返回值,
-
第二个 * 代表任意类的对象,
-
第三个 * 代表任意方法,
-
参数列表中的 .. 匹配任意数量的参数
-
*/
-
The execution of any public method:
execution(public * *(..)) -
The execution of any method with a name that begins with
set:execution(* set*(..)) -
The execution of any method defined by the
AccountServiceinterface:execution(* com.xyz.service.AccountService.*(..)) -
The execution of any method defined in the
servicepackage:execution(* com.xyz.service.*.*(..)) -
The execution of any method defined in the service package or one of its sub-packages:
execution(* com.xyz.service..*.*(..)) -
Any join point (method execution only in Spring AOP) within the service package:
within(com.xyz.service.*) -
Any join point (method execution only in Spring AOP) within the service package or one of its sub-packages:
within(com.xyz.service..*) -
Any join point (method execution only in Spring AOP) where the proxy implements the
AccountServiceinterface:this(com.xyz.service.AccountService)
@Before("execution(* com.xyz.myapp.dao.*.*(..))")
@AfterReturning("com.xyz.myapp.CommonPointcuts.dataAccessOperation()")
指定返回参数
@AfterReturning(
pointcut="com.xyz.myapp.CommonPointcuts.dataAccessOperation()",
returning="retVal")
public void doAccessCheck(Object retVal) {
// ...
}制定异常（返回）
@Aspect
public class AfterThrowingExample {
@AfterThrowing(
pointcut="com.xyz.myapp.CommonPointcuts.dataAccessOperation()",
throwing="ex")
public void doRecoveryActions(DataAccessException ex) {
// ...
}
}获取输出参数
//先定义切点（Pointcut）
@Pointcut("com.xyz.myapp.CommonPointcuts.dataAccessOperation() && args(account,..)")
private void accountDataAccessOperation(Account account) {}
//使用切点
@Before("accountDataAccessOperation(account)")
public void validateAccount(Account account) {
// ...
}
使用
@Configuration
@ComponentScan("com.test2")
@EnableAspectJAutoProxy
public class Config1 {
public static void main(String[] args) {
AnnotationConfigApplicationContext content = new AnnotationConfigApplicationContext(Config1.class);
System.out.println("********BeanDefinition*********");
Arrays.stream(content.getBeanDefinitionNames()).forEach(val -> {
System.out.println(val);
});
System.out.println("********BeanDefinition*********");
System.out.println("############spring--容器启动完成############");
TestService testService = content.getBean(TestService.class);
testService.addUser();
}
}
//控制台输出
LogAspect--around-before
LogAspect--before
com.test2.bean.TestService执行addUser动作
LogAspect--afterReturning返回结果：添加成功
LogAspect--after
LogAspect--around-after返回值：添加成功Aspect类定义
package com.test2.bean;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
/**
* Created by user on 2021/1/18.
*/
@Component
@Aspect
public class LogAspect {
@Pointcut("execution(* com.test2.bean.TestService.*(..))")
public void pointCut() {
}
//JoinPoint必须是方法的第一个参数，否则spring会无法识别。具体查看spring源码分析
@Before("execution(public String com.test2.bean.TestService.addUser())")
public void before(JoinPoint point) {
System.out.println(point.getSignature().getName());//方法
System.out.println(point.getArgs());//参数
System.out.println("LogAspect--before");
}
@After(value = "pointCut()")
public void after() {
System.out.println("LogAspect--after");
}
@AfterReturning(value = "pointCut()", returning = "result")
public void afterReturning(Object result) {
System.out.println("LogAspect--afterReturning" + "返回结果：" + result);
}
@AfterThrowing(value = "pointCut()", throwing = "exception")
public void afterThrowing(Exception exception) {
System.out.println("LogAspect--AfterThrowing" + exception.getMessage());
}
@Around("pointCut()")
public Object around(ProceedingJoinPoint point) throws Throwable {
System.out.println("LogAspect--around-before");
long beginTime = System.currentTimeMillis();
Object result = point.proceed();//实际方法执行
long time = System.currentTimeMillis() - beginTime;
System.out.println("LogAspect--around-after" + "返回值：" + result);
return result;
}
}
@Service
public class TestService {
public String addUser() {
System.out.println(this.getClass().getName() + "执行addUser动作");
int i = 1/0;//手动抛出异常【如果手动抛出异常时，afterThrowing会被执行，且能够接受到具体的异常信息】
return "添加成功";
}
}AOP原理
@EnableAspectJAutoProxy
//加入AOP后，才开始起作用
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
//给容器导入某个Bean
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
* to standard Java interface-based proxies. The default is {@code false}.
*/
boolean proxyTargetClass() default false;
/**
* Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
* for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
* Off by default, i.e. no guarantees that {@code AopContext} access will work.
* @since 4.3.1
*/
boolean exposeProxy() default false;
}导入组件（AspectJAutoProxyRegistrar）
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
}
给Spring容器导入Bean---AspectJAutoProxyRegistrar，由于实现了ImportBeanDefinitionRegistrar，也就是在Spring容器启动的时候会调用registerBeanDefinitions方法；
这个是invokeBeanFactoryPostProcessors的时候执行，这个可以给Spring容器直接导入Bean的定义；然后spring在IOC的时候，就会创建对应的bean
ImportBeanDefinitionRegistrar
org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
关键方法执行
#Spring-AOP之AspectJ切面理解
+ 在配置类中加入@EnableAspectJAutoProxy注解支持
(1)问题，为什么加入了@EnableAspectJAutoProxy注解后，spring-AOP就起作用了?
(1)通过使用注解后，注解内部导入了org.springframework.context.annotation.AspectJAutoProxyRegistrar类【这个类起关键作用】
+ 注解@EnableAspectJAutoProxy定义
//org.springframework.context.annotation.AspectJAutoProxyRegistrar
@Import(AspectJAutoProxyRegistrar.class)//导入了AspectJAutoProxyRegistrar
public @interface EnableAspectJAutoProxy {}
+ AspectJAutoProxyRegistrar类干了什么事情？【@Import(AspectJAutoProxyRegistrar.class)//导入了AspectJAutoProxyRegistrar】
AspectJAutoProxyRegistrar类实现了接口 ImportBeanDefinitionRegistrar（org.springframework.context.annotation包）
+ 在spring容器初始化（refresh()）的时候，会调用invokeBeanFactoryPostProcessors(beanFactory)方法
//Invoke factory processors registered as beans in the context【执行工厂后置处理器，注册一个bean在spring-上下文】
invokeBeanFactoryPostProcessors(beanFactory)
在这个方法里面就实现了对实现接口ImportBeanDefinitionRegistrar的处理【具体可以看另一篇文章针对ImportBeanDefinitionRegistrar合适处理的分析】
文章地址：https://blog.csdn.net/qqzhengwei/article/details/113102969
+ 上面执行完毕后，就会把 AspectJAutoProxyRegistrar 【完成AnnotationAwareAspectJAutoProxyCreator初始化new】
org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator的registerBeanDefinitions方法
+ AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)//完成下面说的注册到spring容器中
beanName=org.springframework.aop.config.internalAutoProxyCreator 实例为 AnnotationAwareAspectJAutoProxyCreator，注册到spring-beanFactory中
+ 最终给spring容器注册了beanName=org.springframework.aop.config.internalAutoProxyCreator,实例为 AnnotationAwareAspectJAutoProxyCreator
+ 上面只是把AnnotationAwareAspectJAutoProxyCreator的beanDefinition注册到spring容器，但是这个时候bean还没有被实例化
+ AnnotationAwareAspectJAutoProxyCreator 在何时被初始化的呢？
【查看 AnnotationAwareAspectJAutoProxyCreator 类图结构】--看看他实现了什么接口，以及什么时候完成的初始化
1）、实现了 BeanFactoryAware 接口，也就是在 AnnotationAwareAspectJAutoProxyCreator spring创建这个bean的时候，会注册 beanFactory实例进来
这个时候就可以通过beanFactory放注册的bean
2）、实现了 BeanPostProcessor ,bean的后置处理器【这个都是在bean实例化的时候做的动作】
--postProcessBeforeInitialization 在bean初始化之前做的事情
--postProcessAfterInitialization 在bean实例化之后做的事情
+ org.springframework.context.support.AbstractApplicationContext的refresh()
+ registerBeanPostProcessors(beanFactory);//(注册bean的后置处理器，用来拦截bean的创建)Register bean processors that intercept bean creation.
+ PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this)
通过PostProcessorRegistrationDelegate去处理
//通过beanFactory在spring容器中把上面定义的AnnotationAwareAspectJAutoProxyCreator给找到
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
//通过beanFactory-根据beanName名称（org.springframework.aop.config.internalAutoProxyCreator）去容器中获取这个bean
//getBean，去spring容器获取bean，如果spring容器找不到，就去创建；（bean的实例化过程实现）
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class)
+ getBean的执行链路
org.springframework.beans.factory.support.AbstractBeanFactory类中的方法（为beanFactory的抽象类）
1）、getBean(String name, Class<T> requiredType)
2）、doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
3）、getSingleton(String beanName, ObjectFactory<?> singletonFactory)最终还是会执行下面createBean方法
3）、sharedInstance = getSingleton(beanName, () -> {return createBean(beanName, mbd, args))};之说核心方法
4）、createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
--org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
【这里执行了BeforeInstantiation】Object bean = resolveBeforeInstantiation(beanName, mbdToUse)
//Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
5）、doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
一、循环依赖问题解决（较早暴露bean）
二、createBeanInstance 通过无参构造函数实例化bean
三、populateBean 给bean的各种属性赋值
四、initializeBean 初始化bean
1）、invokeAwareMethods 调用实现了Aware接口的方法
2）、applyBeanPostProcessorsBeforeInitialization 执行前置处理器 postProcessBeforeInitialization
3）、invokeInitMethods 调用初始化方法：例如afterPropertiesSet实现InitializingBean接口
4）、postProcessAfterInitialization 执行后置处理器 postProcessAfterInitialization
【这个后置处理器就会调用 AnnotationAwareAspectJAutoProxyCreator 的postProcessBeforeInitialization和postProcessAfterInitialization方法】
+ 以上就完成了AnnotationAwareAspectJAutoProxyCreator的创建和注册到spring容器
AnnotationAwareAspectJAutoProxyCreator实现了接口BeanPostProcessor后置处理器，也就是以后创建任何Bean的都是都会调用
----》postProcessBeforeInitialization
---》postProcessAfterInitialization
方法，这样就实现了拦截处理。
InstantiationAwareBeanPostProcessor 后置处理器作用（使用契机）
==================================【以下是在实例化之前做的事情】 doCreateBean之前做的
+ interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor
InstantiationAwareBeanPostProcessor 也是一个BeanPostProcessor,只是是BeanPostProcessor的子接口
+ AnnotationAwareAspectJAutoProxyCreator ==> InstantiationAwareBeanPostProcessor【这个叫实例化之前的后置处理器】
=========
+ org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)
在spring容器初始化完成finishBeanFactoryInitialization
【AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前都会有一个拦截的作用 因为他是一个 InstantiationAwareBeanPostProcessor 后置处理器】
【在容器AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory)执行时产生的效果】--实例化bean容器里面所有的bean
+ 遍历容器中所有的bean,依次创建getBean(beanName)对象；beanFactory的beanDefinitionNames属性
+ [+ getBean的执行链路]查看上面的getBean执行链路
+ 创建bean实例
1）、先从缓存中看看是否存在bean实例；
如果能够获取到直接从缓存中获取（单例的bean），如果不存在的话，否则创建bean；
2）、createBean创建bean
【BeanPostProcessors 是在对象创建完成，初始化前后调用】
【InstantiationAwareBeanPostProcessor 是在对象，创建之前调用】
1）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse)执行：创建bean前的，处理器
代码注释Give BeanPostProcessors a chance to return a proxy instead of the target bean instance
给BeanPostProcessors（后置处理器）一个机会，来返回一个代理对象，来替代真实的对象【代理就是在这里开始的】
+ 【这里执行了BeforeInstantiation】Object bean = resolveBeforeInstantiation(beanName, mbdToUse)
+ resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)
//执行前置
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
如果bp instanceof InstantiationAwareBeanPostProcessor 就执行后置处理器的postProcessBeforeInstantiation方法
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
执行后置--postProcessAfterInitialization
}
2）、 希望后置处理器在这里可以返回一个代理对象，如果能返回就使用代理对象bean，如果不能返回，就在创建bean;
Object beanInstance = doCreateBean(beanName, mbdToUse, args)
+ AnnotationAwareAspectJAutoProxyCreator.postProcessBeforeInstantiation方法又干了什么事情呢？
要获取代理bean这样获取
BeanFactory接口里面的常量String FACTORY_BEAN_PREFIX = "&";
BeanFactory.FACTORY_BEAN_PREFIX + beanName
1）、postProcessBeforeInstantiation
1）、判断当前bean是否已经增强
2）、在判断beanClass是否是基础类型的（Advice、Pointcut、Advisor、AopInfrastructureBean、@AspectJ）
3）、是否需要跳过shouldSkip()
1）、获取候选的增强器（切面里面的通知方法）【List<Advisor> candidateAdvisors增强器集合】
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
List<Advisor> candidateAdvisors = findCandidateAdvisors();
for (Advisor advisor : candidateAdvisors) {
if (advisor instanceof AspectJPointcutAdvisor &&
((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {
return true;
}
}
return super.shouldSkip(beanClass, beanName);
}
每一个封装的通知方法的增强器是 InstantiationModelAwarePointcutAdvisor；
判断每一个增强器是否是 AspectJPointcutAdvisor 类型的；返回true
2）、永远返回false
2）、创建对象 postProcessAfterInitialization
return wrapIfNecessary(bean, beanName, cacheKey); //包装如果需要的情况下
1）、获取当前bean的所有增强器（通知方法） Object[] specificInterceptors
1、找到候选的所有的增强器（找哪些通知方法是需要切入当前bean方法的）
2、获取到能在bean使用的增强器。
3、给增强器排序使用@Order(3)数值越小，优先级越高。越优先执行
2）、保存当前bean在advisedBeans中；
3）、如果当前bean需要增强，创建当前bean的代理对象；
1）、获取所有增强器（通知方法）
2）、保存到proxyFactory
3）、创建代理对象：Spring自动决定
JdkDynamicAopProxy(config);jdk动态代理；
ObjenesisCglibAopProxy(config);cglib的动态代理；
4）、给容器中返回当前组件使用cglib增强了的代理对象；
5）、以后容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行通知方法的流程；
3）、目标方法执行 ；
容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细信息（比如增强器，目标对象，xxx）；
1）、CglibAopProxy.intercept();拦截目标方法的执行
2）、根据ProxyFactory对象获取将要执行的目标方法拦截器链；
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
1）、List<Object> interceptorList保存所有拦截器
一个默认的ExposeInvocationInterceptor 和 配置的增强器；
2）、遍历所有的增强器，将其转为Interceptor；
registry.getInterceptors(advisor);
3）、将增强器转为List<MethodInterceptor>；
如果是MethodInterceptor，直接加入到集合中
如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
转换完成返回MethodInterceptor数组；
3）、如果没有拦截器链，直接执行目标方法;
retVal = methodProxy.invoke(target, argsToUse)
拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
4）、如果有拦截器链，把需要执行的目标对象，目标方法，
拦截器链等信息传入创建一个 CglibMethodInvocation 对象，
并调用 Object retVal = mi.proceed();
5）、拦截器链的触发过程;
new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()
相当于执行了父类的org.springframework.aop.framework.ReflectiveMethodInvocation.proceed()方法
1)、如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法；
2)、链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
拦截器链的机制，保证通知方法与目标方法的执行顺序；
public Object proceed() throws Throwable {
//currentInterceptorIndex初始化是-1，interceptorsAndDynamicMethodMatchers拦截器链集合
// We start with an index of -1 and increment early.
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
return invokeJoinpoint();
}
//一个一个拦截器链的取
Object interceptorOrInterceptionAdvice =
this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
// Evaluate dynamic method matcher here: static part will already have
// been evaluated and found to match.
InterceptorAndDynamicMethodMatcher dm =
(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
return dm.interceptor.invoke(this);
}
else {
// Dynamic matching failed.
// Skip this interceptor and invoke the next in the chain.
return proceed();
}
}
else {
// It's an interceptor, so we just invoke it: The pointcut will have
// been evaluated statically before this object was constructed.
return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
}
}
# 总结
1）、 @EnableAspectJAutoProxy 开启AOP功能
2）、 @EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareAspectJAutoProxyCreator
3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；
4）、容器的创建流程：
1）、registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean
1）、创建业务逻辑组件和切面组件
2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程
3）、组件创建完之后，判断组件是否需要增强
是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象（cglib）；
5）、执行目标方法：
1）、代理对象执行目标方法
2）、CglibAopProxy.intercept()；
1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；
3）、效果：
正常执行：前置通知-》目标方法-》后置通知-》返回通知
出现异常：前置通知-》目标方法-》后置通知-》异常通知- 拦截器链执行过程
拦截器返回通过
- 拦截器链
- 增强器 InstantiationModelAwarePointcutAdvisor接口的的实例InstantiationModelAwarePointcutAdvisorImpl
动态代理创建
org.springframework.aop.framework.DefaultAopProxyFactory创建代理
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
Class<?> targetClass = config.getTargetClass();
if (targetClass == null) {
throw new AopConfigException("TargetSource cannot determine target class: " +
"Either an interface or a target is required for proxy creation.");
}
//如果实现了接口或者已经是代理类
if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
return new JdkDynamicAopProxy(config);//JDK动态代理
}
return new ObjenesisCglibAopProxy(config);//Cglib动态代理
}
else {
return new JdkDynamicAopProxy(config);
}
}
AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}
⬇️
//实例化剩下的不是懒加载的 单实例Bean
finishBeanFactoryInitialization(beanFactory);
⬇️
beanFactory.preInstantiateSingletons();
⬇️
// ? 构造器执行,创建一个Bean
getBean(beanName);
⬇️
doGetBean
⬇️
getSingleton
⬇️
doCreateBean{
//将需要Autowired 的属性方法执行一遍
populateBean(beanName, mbd, instanceWrapper);
initializeBean(beanName, exposedObject, mbd){
// aware 方法执行,给实现了xxAware的方法设置值
invokeAwareMethods(beanName, bean);
applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName){
beanProcessor.postProcessBeforeInitialization(result, beanName){
invokeAwareInterfaces(bean){
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
}
}
// 初始化方法，执行init
invokeInitMethods(beanName, wrappedBean, mbd);
applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
}
标签：执行,拦截器,Spring,beanName,bean,spring,注解,源代码,public 来源： https://blog.csdn.net/qqzhengwei/article/details/112788609
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。