平凡的柚子
平凡的柚子

Spring AOP 源码分析

寻找入口
Spring 的 AOP 是通过接入 BeanPostProcessor 后置处理器开始的，它是 Spring IOC 容器经常使用到的一个特性，这个 Bean 后置处理器是一个监听器，可以监听容器触发的 Bean 声明周期事件。后置处
理器向容器注册以后，容器中管理的 Bean 就具备了接收 IOC 容器事件回调的能力。

1、BeanPostProcessor 源码

public interface BeanPostProcessor {

    //为在Bean的初始化前提供回调入口
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    //为在Bean的初始化之后提供回调入口
    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

}

这两个回调的入口都是和容器管理的 Bean 的生命周期事件紧密相关，可以为用户提供在 Spring IOC容器初始化 Bean 过程中自定义的处理操作。

2、AbstractAutowireCapableBeanFactory 类对容器生成的 Bean 添加后置处理器

BeanPostProcessor 后置处理器的调用发生在 Spring IOC 容器完成对 Bean 实例对象的创建和属性的依赖注入完成之后，在对 Spring 依赖注入的源码分析过程中我们知道，当应用程序第一次调用 getBean()
方法(lazy-init 预实例化除外)向 Spring IOC 容器索取指定 Bean 时触发 Spring IOC 容器创建 Bean 实例 对 象 并 进 行 依 赖 注 入 的 过 程 ， 其 中 真 正 实 现 创 建 Bean 对 象 并 进 行 依 赖 注 入 的 方 法 是AbstractAutowireCapableBeanFactory 类的 doCreateBean()方法，主要源码如下：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {

       ....// Initialize the bean instance.
        //Bean对象的初始化，依赖注入在此触发
        //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean
        Object exposedObject = bean;
        try {
            //将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象
            populateBean(beanName, mbd, instanceWrapper);
            //初始化Bean对象
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
  　　　....return exposedObject;
    }

从上面的代码中我们知道，为 Bean 实例对象添加 BeanPostProcessor 后置处理器的入口的是initializeBean()方法。

3、initializeBean()方法为容器产生的 Bean 实例对象添加 BeanPostProcessor 后置处理器

同样在 AbstractAutowireCapableBeanFactory 类中，initializeBean()方法实现为容器创建的 Bean实例对象添加 BeanPostProcessor 后置处理器，源码如下：

//初始容器创建的Bean实例对象，为其添加BeanPostProcessor后置处理器
    protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        //JDK的安全机制验证权限
        if (System.getSecurityManager() != null) {
            //实现PrivilegedAction接口的匿名内部类
            AccessController.doPrivileged((PrivilegedAction) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            //为Bean实例对象包装相关属性，如名称，类加载器，所属容器等信息
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        //对BeanPostProcessor后置处理器的postProcessBeforeInitialization
        //回调方法的调用，为Bean实例初始化前做一些处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }

        //调用Bean实例对象初始化的方法，这个初始化方法是在Spring Bean定义配置
        //文件中通过init-method属性指定的
        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        //对BeanPostProcessor后置处理器的postProcessAfterInitialization
        //回调方法的调用，为Bean实例初始化之后做一些处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }

        return wrappedBean;
    }

//调用BeanPostProcessor后置处理器实例对象初始化之前的处理方法
    public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException {
        Object result = existingBean;
        //遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            //调用Bean实例所有的后置处理中的初始化前处理方法，为Bean实例对象在
            //初始化之前做一些自定义的处理操作
            Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

//调用BeanPostProcessor后置处理器实例对象初始化之后的处理方法
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException {

        Object result = existingBean;
        //遍历容器为所创建的Bean添加的所有BeanPostProcessor后置处理器
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            //调用Bean实例所有的后置处理中的初始化后处理方法，为Bean实例对象在
            //初始化之后做一些自定义的处理操作
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }


BeanPostProcessor 是一个接口，其初始化前的操作方法和初始化后的操作方法均委托其实现子类来实现，在 Spring 中，BeanPostProcessor 的实现子类非常的多，分别完成不同的操作，如：AOP 面向切面编程的注册通知适配器、Bean 对象的数据校验、Bean 继承属性、方法的合并等等，我们以最简单的AOP 切面织入来简单了解其主要的功能。下面我们来分析其中一个创建 AOP 代理对象的子类AbstractAutoProxyCreator 类。该类重写了 postProcessAfterInitialization()方法。选择代理策略进入 postProcessAfterInitialization()方法，我们发现调到了一个非常核心的方法 wrapIfNecessary()，其源码如下：


@Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) throws BeansException {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        // 判断是否不应该代理这个 bean
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        /**
        * 判断是否是一些 InfrastructureClass 或者是否应该跳过这个 bean。
        * 所谓 InfrastructureClass 就是指 Advice/PointCut/Advisor 等接口的实现类。
        * shouldSkip 默认实现为返回 false,由于是 protected 方法， 子类可以覆盖。
        */
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // 获取这个 bean 的 advice
        // 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;
    }

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()) {
            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);
        }

        return proxyFactory.getProxy(getProxyClassLoader());
    }



整个过程跟下来，我发现最终调用的是 proxyFactory.getProxy()方法。到这里我们大概能够猜到proxyFactory 有 JDK 和 CGLib 的，那么我们该如何选择呢？最终调用的是 DefaultAopProxyFactory
 的 createAopProxy()方法：


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);
            }
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }



上面我们已经了解到 Spring 提供了两种方式来生成代理方式有 JDKProxy 和 CGLib。下面我们来研究一下 Spring 如何使用 JDK 来生成代理对象，具体的生成代码放在 JdkDynamicAopProxy 这个类中，
 直接上相关代码：


@Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating JDK dynamic proxy: target source is " + this.advised.getTargetSource());
        }
        Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }



通过注释我们应该已经看得非常明白代理对象的生成过程，此处不再赘述。下面的问题是，代理对象生成了，那切面是如何织入的？我们知道 InvocationHandler 是 JDK 动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。而从 JdkDynamicAopProxy 的源码我们可以看到这个类其实也实现了 InvocationHandler，下面我们分析 Spring AOP 是如何织入切面的，直接上源码看 invoke()方法：


public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        MethodInvocation invocation;
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        try {
            //eqauls()方法，具目标对象未实现此方法
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            //hashCode()方法，具目标对象未实现此方法
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            //Advised接口或者其父接口中定义的方法,直接反射调用,不应用通知
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            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);

            // Get the interception chain for this method.
            //获取可以应用到此方法上的Interceptor列表
            List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            //如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)
            if (chain.isEmpty()) {
                // 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                //创建MethodInvocation
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }

            // Massage return value if necessary.
            Class returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                // Special case: it returned "this" and the return type of the method
                // is type-compatible. Note that we can't help if the target sets
                // a reference to itself in another returned object.
                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // Must have come from TargetSource.
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }


主要实现思路可以简述为：首先获取应用到此方法上的通知链（Interceptor Chain）。如果有通知，应用通知，并执行 JoinPoint；如果没有通知，则直接反射执行 JoinPoint。而这里的关键是通知链是如
 何获取的以及它又是如何执行的呢？现在来逐一分析。首先，从上面的代码可以看到，Advised.getInterceptorsAndDynamicInterceptionAdvice()这个方法来获取的，的实现逻辑：


public List getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class targetClass) {
        MethodCacheKey cacheKey = new MethodCacheKey(method);
        List cached = this.methodCache.get(cacheKey);
        if (cached == null) {
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                    this, method, targetClass);
            this.methodCache.put(cacheKey, cached);
        }
        return cached;
    }


这个方法执行完成后，Advised 中配置能够应用到连接点（JoinPoint）或者目标类（Target Object）的 Advisor 全部被转化成了 MethodInterceptor，接下来我们再看下得到的拦截器链是怎么起作用的


//如果没有可以应用到此方法的通知(Interceptor)，此直接反射调用 method.invoke(target, args)
            if (chain.isEmpty()) {
                // 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                //创建MethodInvocation
                invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }



从这 段 代 码 可 以 看 出 ， 如 果 得 到 的 拦 截 器 链 为 空 ， 则 直 接 反 射 调 用 目 标 方 法 ， 否 则 创 建MethodInvocation，调用其 proceed()方法，触发拦截器链的执行，来看下具体代码:


public Object proceed() throws Throwable {
        //    We start with an index of -1 and increment early.
        //如果Interceptor执行完了，则执行joinPoint
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        //如果要动态匹配joinPoint
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            //动态匹配：运行时参数是否满足匹配条件
            if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                //动态匹配失败时,略过当前Intercetpor,调用下一个Interceptor
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            //执行当前Intercetpor
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }



至此，通知链就完美地形成了。我们再往下来看 invokeJoinpointUsingReflection()方法，其实就是反射调用：


public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
            throws Throwable {

        // Use reflection to invoke the method.
        try {
            ReflectionUtils.makeAccessible(method);
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            // Invoked method threw a checked exception.
            // We must rethrow it. The client won't see the interceptor.
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
                    method + "] on target [" + target + "]", ex);
        }
        catch (IllegalAccessException ex) {
            throw new AopInvocationException("Could not access method [" + method + "]", ex);
        }
    }



Spring AOP运行时序图






































你可能感兴趣的:(Spring AOP 源码分析)






    

  • SpringMVC设置全局异常处理器
水岸齐天
javaspring

    文章目录背景分析使用@ControllerAdvice（@RestControllerAdvice）+@ExceptionHandler实现全局异常全局异常处理-多个处理器匹配顺序存在一个类中存在不同的类中对于过滤器和拦截器中的异常，有两种思路可以考虑背景在项目中我们有需求做一个全局异常处理，来规范所有出去的异常信息。参考：官方文档分析首先ControllerAdvice(RestControll
    

    • 

  • 使用多线程的方式模拟高并发请求接口，用于自测接口的稳定性【项目】
还算善良_
私有代码库工具类javalist数据结构

    packagecom.gitee.taven.test;importcom.gitee.taven.ApiResult;importcom.gitee.taven.aop.RepeatSubmitAspect;importorg.slf4j.Logger;importorg.slf4j.LoggerFactory;importorg.springframework.beans.factory.an
    

    • 

  • springboot集成logback-spring.xml文件
RT_0114
SpringBootspringbootspringlogback

    彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
    

    • 

  • eclipse导入项目 warning报错 org.springframework.ide.eclipse.core.springnature
zhangfeng1133
ideeclipsejava

    报错org.springframework.ide.eclipse.core.springnature报错信息"org.springframework.ide.eclipse.core.springnature"通常表示EclipseIDE中与Spring框架集成的插件出现了问题。这个错误可能是因为SpringIDE插件没有正确安装或配置，或者Eclipse的更新过程中出现了问题。解决方法：确认S
    

    • 

  • linux安装docker及docker-compose 部署spring boot项目
时而有事儿
dockerlinuxdockerlinuxspringboot

    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
    

    • 

  • Websocket服务监听收发消息
beiback
Java服务器问题websocket网络协议网络

    目录1.pom依赖坐标2.项目配置端口和项目包名2.创建处理器3.注册处理器4.前端页面1.pom依赖坐标org.springframework.bootspring-boot-starter-websocket2.项目配置端口和项目包名application.propertiesserver.port=8088//路径规范：为应用的所有servlet提供一个统一的前缀，使URL结构更加清晰和一致
    

    • 

  • 基于SSM+Vue企业销售培训系统 企业人才培训系统 企业课程培训管理系统 企业文化培训班系统Java
计算机程序老哥

    作者主页：计算机毕业设计老哥有问题可以主页问我一、开发介绍1.1开发环境开发语言：Java数据库：MySQL系统架构：B/S后端：SSM(Spring+SpringMVC+Mybatis)前端：Vue工具：IDEA或者Eclipse，JDK1.8，Maven二、系统介绍2.1图片展示注册登录页面：登陆.png前端页面功能：首页、培训班、在线学习、企业文化、交流论坛、试卷列表、系统公告、留言反馈、个
    

    • 

  • 使用Spring Boot Admin监控和管理Spring Boot应用程序
岚珂瓜呱
springbootspringboot后端javaspringmybatis数据库

    使用SpringBootAdmin监控和管理SpringBoot应用程序SpringBootAdmin是一个用于监控和管理SpringBoot应用程序的开源工具。它提供了一个直观的用户界面，用于查看应用程序的健康状态、详细信息、日志等，并支持一些管理功能。下面是一个简单的示例，演示如何在SpringBoot应用程序中集成SpringBootAdmin：添加SpringBootAdmin依赖：首先，
    

    • 

  • 使用Spring Security进行LDAP（轻量目录访问协议）认证
岚珂瓜呱
springbootspringjava数据库后端开发语言springboot

    使用SpringSecurity进行LDAP（轻量目录访问协议）认证使用SpringSecurity进行LDAP认证非常简单，您只需配置SpringSecurity以连接到LDAP服务器并执行认证即可。以下是一个简单的示例，演示如何在SpringBoot应用程序中实现LDAP认证：添加SpringSecurity和SpringLDAP依赖：首先，您需要添加SpringSecurity和Spring
    

    • 

  • nginx upstream server主动健康监测模块添加https检测功能【上】
码农心语
nginx学习c++开发LINUXnginxhttps运维健康检测upstreamproxy

    1缘起  前面的《nginxupstreamserver主动健康检测模块ngx_http_upstream_check_module使用和源码分析》系列已经分析了ngx_http_upstream_check_module的实现原理，并且在借助这个模块的框架实现了一个udp健康检测的新功能。  但是ngx_http_upstream_check_module还缺乏基于https监测上游服务器健康状
    

    • 

  • 论文整理：隐私签名
yixvxi
Survey文档资料学习

    最近准备开题了（苦恼…），整理一些看过/没看过的论文。持续更新…数字签名：隐私数字签名的定义&安全性(book)0.Deffie-Hellman.NewDirectionsinCryptography.1976Katz,J.(2010).DigitalSignatures:BackgroundandDefinitions.In:DigitalSignatures.Springer,Boston,M
    

    • 

  • 配置 IDEA 远程连接应用服务器
O_Neal

    当调试Web应用时，经常需要使用ide远程连接，来进行debug调试。使用Springboot内置服务器和使用Tomcat服务器是常见的应用部署方式，可以用不同的配置方式来启动远程debug模式。Springboot应用1.配置启动参数运行jar时加上debug参数，例如java-jar-Xdebug-Xrunjdwp:transport=dt_socket,address=60222,suspe
    

    • 

  • spring security 权限(注解)
LaoCat__
javaspringcloudweb后端javaspringbootspringsecurity

    写在前边整理的知识点都是从其他博客中来，如有侵权，立删！参考:https://blog.csdn.net/qq_32867467/article/details/103097190正题:SpringSecurity默认是禁用注解的，要想开启注解，要在继承WebSecurityConfigurerAdapter的类加@EnableMethodSecurity注解，并在该类中将Authenticati
    

    • 

  • spring cloud gateway k8s优雅启停
luffy_1993
kubernetes容器云原生

    通过配置readiness探针和preStophook，实现优雅启动和停止（滚动部署）1.k8s工作负载配置readinessProbe:httpGet:path:/datetimeport:8080scheme:HTTPinitialDelaySeconds:30timeoutSeconds:1periodSeconds:30successThreshold:1failureThreshold:
    

    • 

  • Websocket + Vue使用
人间观察师
websocketvue.js前端

    这里有一篇文档可以参考一下>闪现POM文件org.springframework.bootspring-boot-starter-websocket2.7.0WebSocketConfig配置importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configura
    

    • 

  • [套路] 浏览器引入Vue.js场景-WangEditor富文本编辑器的使用 (永久免费)
Grandpa_Rick
套路frontendvue.js前端javascriptwangEditor

    系列文章目录[套路]el-table多选属性实现单选效果[套路]基于服务内存实现的中文拼音混合查询[套路]Bypass滑块验证码目录系列文章目录前言一、实现1.1场景1.2Window对象简介1.3引入WangEditor1.4页面配置前言公司使用freemarker的老旧SpringBootWeb后台项目,前两年通过浏览器引入js的方式使用Vue简单升级了下,方便迭代功能.近期一个很简单的功能需
    

    • 

  • spring boot高级运用：使用Spring Cloud Config实现集中式配置管理，动态管理应用程序配置
岚珂瓜呱
springbootspringboot后端java开发语言spring

    使用SpringCloudConfig实现集中式配置管理，动态管理应用程序配置使用SpringCloudConfig实现集中式配置管理非常强大，它允许您将应用程序的配置从代码中分离出来，并集中存储在一个或多个配置存储库中（例如Git，SVN等）。下面是一个简单的示例，演示如何使用SpringCloudConfig来实现这一点：创建配置存储库：在您的版本控制系统（例如Git）中创建一个配置存储库，用
    

    • 

  • springboot项目学习-瑞吉外卖（1）
两仪式quq
springboot学习java瑞吉外卖

    第一天任务如下：建立基本架构完成登录、退出功能注意：本博客没有使用网上教程里的mybatis-plus，使用的是mybatis；数据库连接池也没有使用教程里的druid，使用的是spring自带的连接池基本架构common包：存放的通用类R，用来给前端返回Json格式的数据config包：存放配置类，在今天的任务中主要解决静态资源路径映射问题controller包entity包：存放实体类mapp
    

    • 

  • springboot中get post put delete 请求区别详解
developerFBI
JAVASpringbootjava

    Spring4.3中引进了｛@GetMapping、@PostMapping、@PutMapping、@DeleteMapping、@PatchMapping｝来帮助简化常用的HTTP方法的映射并更好地表达被注解方法的语义。1.@GetMapping：处理get请求，传统的RequestMapping来编写应该是@RequestMapping(value=“/get/{id}”,method=Re
    

    • 

  • docker-ce安装
蚁景网络安全
dockereureka容器

    安装docker-ce使用清华镜像源加速安装docker-ce原文：docker-ce|镜像站使用帮助|清华大学开源软件镜像站|TsinghuaOpenSourceMirror#方法一exportDOWNLOAD_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce"#如果使用curl，执行如下命令curl-fsSLhttps://get.dock
    

    • 

  • 第10讲_Spring对Dao的支持
吴国友

    Spring框架优秀就是在于MVC开发的时候一旦需要对底层的数据库操作，它可以很好的支持JDBC技术，还有现在主流的ORM框架（Hibernate,MyBatis）技术。重点先介绍Spring对JDBC支持。在Spring对JDBC支持中提供了一个模板JdbcTemplate，此模板封装了对JDBC操作的许多方法，且消除了忽视资源释放而引起的漏洞Spring对JDBC操作需要导入的jar（开发环境
    

    • 

  • 05. spring-boot对spring-mvc的自动配置
马晓钧

    spring-mvc的自动配置viewResolver：视图解析器：根据方法的返回值得到视图对象(View)。//会将容器中已有的ViewResolver和自己定义的ViewResolver全部add进去ContentNegotiatingViewResolver自定义视图解析器：//需要实现ViewResolver，并注入进容器@ConfigurationpublicclassViewConfi
    

    • 

  • rabbitmq发送json消息
陌以然I
rabbitmqjava分布式

    rabbitmq发送json格式消息packageorg.secp.rabbitmq.exchange;importorg.springframework.amqp.core.Binding;importorg.springframework.amqp.core.BindingBuilder;importorg.springframework.amqp.core.Queue;importorg.s
    

    • 

  • 【Elasticsearch】从零开始搭建ES8集群并且集成到Springboot，更好的服务电商类等需要全文索引的项目（一）
Smily清禾酥酒
中间件elasticsearchspringbootlucenejava全文检索

    从零开始搭建Elasticsearch集群（一）从零开始搭建Elasticsearch8.6集群（一）简单介绍下Elasticsearch，以及为何使用它下载Elasticsearch准备服务器解压安装配置文件elasticsearch.yml修改调整JVM运行内存设置密码证书认证1.生成证书2.生成秘钥3.迁移凭证地址到config目录下4.其他集群都要将这个凭证移动到这个ES安装的config
    

    • 

  • JdkDynamicAopProxy学习
weixin_44877172
Spring学习javaspring

    简介JdkDynamicAopProxy#invoke是SpringAOP（面向切面编程）框架中用于动态代理的核心方法之一。这个方法是在使用JDK动态代理时，通过JdkDynamicAopProxy类创建的代理对象上调用目标方法时，被自动调用的。以下是该方法的解析：方法签名首先，我们先看一下invoke方法的签名：publicObjectinvoke(Objectproxy,Methodmetho
    

    • 

  • 某小厂java后端初面，记录一下
bpmh
Java开发1天1道面试题java面试

    好吧，，，，，本人很菜，再接再励吧，继续刷。简单记录一下面试题，未亡羊补牢呗。1.liftjoin;innerjoin;rightjoin的区别2.union和unionall的区别3.like查询会走索引吗？4.主键和索引的区别5.count(*),count(1),count(ID)的区别6.exists了解吗？作用是什么7.线程池了解吗？8.spring创建的bean是单例模式还是多例模式，
    

    • 

  • Vue+SpringBoot打造数据可视化的智慧河南大屏
桑程程
信息可视化vue.jsspringboot前端javascript后端springcloud

    目录一、摘要1.1项目介绍1.2项目录屏二、功能模块三、系统展示四、核心代码4.1数据模块A4.2数据模块B4.3数据模块C4.4数据模块D4.5数据模块E五、免责说明一、摘要1.1项目介绍基于JAVA+Vue+SpringBoot+MySQL的数据可视化的智慧河南大屏，包含了GDP、人口、土地面积、企业数、人均收入数据排行、地图展示等模块，还包含系统自带的用户管理、部门管理、角色管理、菜单管理、
    

    • 

  • spring boot 验证码源代码，直接复制使用
古猿写代码
springbootspringbootjava前端

    使用springboot实现验证码源代码，直接复制使用publicvoidgetCodeImage(HttpServletResponseresponse){//随机生成4位验证码RandomGeneratorrandomGenerator=newRandomGenerator("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVW
    

    • 

  • 如何在Spring Boot应用中高效集成Spring Cache与Redis实现高性能缓存机制
yangqjiayou
spring缓存springboot

    一、引言在现代Web应用程序开发中，缓存是一种常见的优化手段，能够显著提升系统性能，减轻数据库负载。SpringCache作为Spring框架内建的缓存抽象层，提供了一种简单易用的方式来统一处理缓存逻辑。而Redis作为一种高性能的内存键值存储系统，经常被选作SpringCache的后端存储。本文将通过一个真实的项目实例，详细介绍SpringCache的使用方法及其与Redis的集成过程。二、Sp
    

    • 

  • @SpringBootApplication ：简化 Spring Boot 项目的配置和初始化过程
wddblog
javaspringbootspringboot后端java

    @SpringBootApplication是SpringBoot框架中的一个核心注解，它用于简化SpringBoot项目的配置和初始化过程。通过使用该注解，开发者可以快速地创建一个独立、可执行的Spring应用程序，而无需编写大量的配置代码。一、@SpringBootApplication的基本概念@SpringBootApplication是一个复合注解，它实际上包含了三个关键的注解：@Spr
    

    • 

  • PHP，安卓，UI，java，linux视频教程合集
cocos2d-x小菜
javaUIPHPandroidlinux

    ╔-----------------------------------╗┆                           
    

    • 

  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
bozch
.net.net mvc

    在.net mvc5中，在执行某一操作的时候，出现了如下错误：
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。 
&
    

    • 

  • Java 对象大小的计算
e200702084
java

                              Java对象的大小
如何计算一个对象的大小呢？
   
    

    • 

  • Mybatis Spring
171815164
mybatis

    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    

    • 

  • JVM 不稳定参数
g21121
jvm

            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    

    • 

  • 用户自动登录网站
永夜-极光
用户

    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码
2.思路:将用户的信息保存为cookie
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    

    • 

  • centos7 安装后失去win7的引导记录
程序员是怎么炼成的
操作系统

    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    

    • 

  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
aijuans
oracle

    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    

    • 

  • JavaEE开源快速开发平台G4Studio_V3.2发布了
無為子
AOPoraclemysqljavaeeG4Studio

     
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。
 
访问G4Studio网站
http://www.g4it.org  
G4Studio_V3.2版本变更日志
功能新增
(1).新增了系统右下角滑出提示窗口功能。
(2).新增了文件资源的Zip压缩和解压缩
    

    • 

  • Oracle常用的单行函数应用技巧总结
百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数

    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心)
一:字符函数:
.UPPER(字符串) 将字符串转为大写
.LOWER (字符串) 将字符串转为小写
.INITCAP(字符串) 将首字母大写
.LENGTH (字符串) 字符串的长度
.REPLACE(字符串,'A','_') 将字符串字符A转换成_ 
    

    • 

  • Mockito异常测试实例
bijian1013
java单元测试mockito

    Mockito异常测试实例：
package com.bijian.study;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.
    

    • 

  • GA与量子恒道统计
Bill_chen
JavaScript浏览器百度Google防火墙

    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下：
 
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    

    • 

  • 【Linux命令三】Top命令
bit1129
linux命令

    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果：
 
 
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total, 4 running, 198 sl
    

    • 

  • spring四种依赖注入方式
白糖_
spring

      平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    

    • 

  • angular.injector
boyitech
AngularJSAngularJS API

    angular.injector
  描述: 创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.   使用方法: angular.injector(modules, [strictDi])   参数详解: Param Type Details mod
    

    • 

  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
bylijinnan
Integer

    
public class PC {
/**
* 题目：生产者-消费者。
* 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
*/
private static final Integer[] val=new Integer[10];
private static
    

    • 

  • 使用Struts2.2.1配置
Chen.H
apachespringWebxmlstruts

    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar
struts2-core-2.2.1.jar struts2-sp
    

    • 

  • [职业与教育]青春之歌
comsci
教育

    
       每个人都有自己的青春之歌............但是我要说的却不是青春...
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的....
  &nbs
    

    • 

  • oracle连接(join)中使用using关键字
daizj
JOINoraclesqlusing

    在oracle连接(join)中使用using关键字
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables.
Evaluate the following SQL statement:
SELECT oi.order_id, product_id, order_date
FRO
    

    • 

  • NIO示例
daysinsun
nio

    NIO服务端代码：
public class NIOServer {
private Selector selector;
public void startServer(int port) throws IOException {
ServerSocketChannel serverChannel = ServerSocketChannel.open(
    

    • 

  • C语言学习homework1
dcj3sjt126com
chomework

    0、 课堂练习做完
1、使用sizeof计算出你所知道的所有的类型占用的空间。
int x;
sizeof(x);
 
sizeof(int);
 
# include <stdio.h>
int main(void)
{
int x1;
char x2;
double x3;
float x4;
printf(&quo
    

    • 

  • select in order by , mysql排序
dcj3sjt126com
mysql

    If i select like this:
SELECT id FROM users WHERE id IN(3,4,8,1);
This by default will select users in this order
1,3,4,8,
I would like to select them in the same order that i put IN() values so: 
    

    • 

  • 页面校验-新建项目
fanxiaolong
页面校验

    $(document).ready(
function() {
var flag = true;
$('#changeform').submit(function() {
var projectScValNull = true;
var s ="";
var parent_id = $("#parent_id").v
    

    • 

  • Ehcache（02）——ehcache.xml简介
234390216
ehcacheehcache.xml简介

    ehcache.xml简介
 
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    

    • 

  • junit 4.11中三个新功能
jackyrong
java

    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如
import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    

    • 

  • 国外程序员爱用苹果Mac电脑的10大理由
php教程分享
windowsPHPunixMicrosoftperl

    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因：
1、Mac OS X 是基于 Unix 的
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    

    • 

  • 位运算、异或的实际应用
wenjinglian
位运算

    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。
      三． 位操作与空间压缩，针对筛素数进行空间压缩。
   &n
    

    • 

  • weblogic部署项目出现的一些问题（持续补充中……）
Everyday都不同
weblogic部署失败

    好吧，weblogic的问题确实……
 
问题一：
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    

    • 

  • tomcat7性能调优（01）
toknowme
tomcat7

     
 
Tomcat优化： 1、最大连接数最大线程等设置
<Connector port="8082" protocol="HTTP/1.1"
               useBodyEncodingForURI="t
    

    • 

  • PO VO DAO DTO BO TO概念与区别
xp9802
javaDAO设计模式bean领域模型

    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    

    •