哼哼爸比
哼哼爸比

解析Spring Boot的AOP原理

目录

一、概述

二、示例

三、Spring AOP如何进行初始化？

1.添加@EnableAspectJAutoProxy注解

2.IOC容器初始化，执行refresh()方法

3.执行registerBeanPostProcessor()

4.执行finishBeanFactoryInitialization(beanFactory)

4.1. 情况一：如果此时的bean是切面类（标注@Aspect）。

4.2. 情况二：此时的bean是需要被切的类（即@Pointcut("a.b.c")中a.b.c覆盖到的类）

四、Spring AOP是如何起作用的？

五、总结

一、概述

AOP(Aspect-Oriented Programming) 面向切面编程。Spring Aop是Spring三大核心思想之一，其应用场景化非常多，比如日志、事务、安全、缓存等功能。分析Spring AOP之前，建议先提前了解下什么是spring容器和容器初始化，这样对以下的Spring AOP的分析更有帮助。 Spring AOP的原理，简单的说，可以从两个方面着手，即Spring AOP如何进行初始化？Spring AOP是如何起作用的？围绕这两点，我们展开分析，首先举个简单的例子，这样对分析更具有实质性，也更容易理解。

二、示例

以下使用的spring Boot版本为：2.3.5.RELEASE

/**
 * spring boot启动类
 * 添加@EnableAspectJAutoProxy注解，它提供了spring aop初始化的核心功能
 */
@SpringBootApplication
@EnableAspectJAutoProxy
public class ProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApplication.class, args);
    }
​
}
/**
 *  切面类
 **/
@Aspect
@Component
public class LogAspects {
​
    //抽取公共的切入点表达式
    @Pointcut("execution(public Integer com.micro.provider.service.UserService.*(..))")
    public void pointCut(){};
​
    @Before("pointCut()")
    public void logStart(JoinPoint joinPoint){
        Object[] args = joinPoint.getArgs();
        System.out.println(""+joinPoint.getSignature().getName()+"运行。。。@Before:参数列表是：{"+ Arrays.asList(args)+"}");
    }
​
    @After("pointCut()")
    public void logEnd(JoinPoint joinPoint){
        System.out.println(""+joinPoint.getSignature().getName()+"结束。。。@After");
    }
​
    //JoinPoint一定要出现在参数表的第一位
    @AfterReturning(value="pointCut()",returning="result")
    public void logReturn(JoinPoint joinPoint,Object result){
        System.out.println(""+joinPoint.getSignature().getName()+"正常返回。。。@AfterReturning:运行结果：{"+result+"}");
    }
​
    @AfterThrowing(value="pointCut()",throwing="exception")
    public void logException(JoinPoint joinPoint,Exception exception){
        System.out.println(""+joinPoint.getSignature().getName()+"异常。。。异常信息：{"+exception+"}");
    }
}
/**
 * 应用切面类的接口
 */
public interface UserService {
​
    /**
     * 加法运算
     * @param x
     * @param y
     * @return
     */
    Integer add(Integer x,Integer y);
}
/**
 * 接口实现类
 */
@Service
public class UserServiceImpl implements UserService {
​
    @Override
    public Integer add(Integer x, Integer y) {
        if(x==null||y==null){
            throw  new NullPointerException("参数不能为空");
        }
        return x+y;
    }
}
/**
 * 访问入口
 */
@Controller
@RequestMapping("/user")
public class UserController {
​
    @Autowired
    private UserService userService;
​
    @ResponseBody
    @RequestMapping("/testaop")
    public Integer testaop(Integer x,Integer y){
        Integer result = userService.add(x, y);
        return result;
    }
}

访问http://localhost:8081/cloud-provider/user/testaop?x=1&&y=2之后，返回结果如下：

add运行。。。@Before:参数列表是：{[1, 2]}
add正常返回。。。@AfterReturning:运行结果：{3}
add结束。。。@After

可以看出切面类被应用到了，这个结果是怎么得出的呢，来我们具体分析下。

三、Spring AOP如何进行初始化？

Spring AOP如何进行初始化，它的初始化步骤分为以下几点。

1.添加@EnableAspectJAutoProxy注解

如上面的示例，在启动类添加@EnableAspectJAutoProxy注解，看下他的内部实现。

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
    boolean proxyTargetClass() default false;
​
    boolean exposeProxy() default false;
}
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    ...
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
        ...
    }
}
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
    return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null);
}
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
    return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
private static BeanDefinition registerOrEscalateApcAsRequired(Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
        ...
    } else {
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", -2147483648);
        beanDefinition.setRole(2);
        registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
        return beanDefinition;
    }
}

其本质就是往bean定义注册表中注册AnnotationAwareAspectJAutoProxyCreator类，该类是个后置处理器，继承关系为AnnotationAwareAspectJAutoProxyCreator->AspectJAwareAdvisorAutoProxyCreator->AbstractAdvisorAutoProxyCreator->AbstractAutoProxyCreator->SmartInstantiationAwareBeanPostProcessor->InstantiationAwareBeanPostProcessor->BeanPostProcessor。

AbstractAutoProxyCreator里面实现了识别切面类、应用切面类以及创建代理对象的逻辑。

InstantiationAwareBeanPostProcessor是一个后置处理器，它的作用就是使IOC容器初始化的时候可以应用到AbstractAutoProxyCreator里面的逻辑，完成spring aop的初始化工作。

2.IOC容器初始化，执行refresh()方法

public void refresh() throws BeansException, IllegalStateException {
   // 来个锁，不然 refresh() 还没结束，你又来个启动或销毁容器的操作，那不就乱套了嘛
   synchronized (this.startupShutdownMonitor) {
 
      // 准备工作，记录下容器的启动时间、标记“已启动”状态、处理配置文件中的占位符
      prepareRefresh();
 
      // 这步比较关键，这步完成后，配置文件就会解析成一个个 Bean 定义，注册到 BeanFactory 中，
      // 当然，这里说的 Bean 还没有初始化，只是配置信息都提取出来了，
      // 注册也只是将这些信息都保存到了注册中心(说到底核心是一个 beanName-> beanDefinition 的 Map)
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 
      // 设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
      // 这块待会会展开说
      prepareBeanFactory(beanFactory);
 
      try {
         // 【这里需要知道 BeanFactoryPostProcessor 这个知识点，Bean 如果实现了此接口，
         // 那么在容器初始化以后，Spring 会负责调用里面的 postProcessBeanFactory 方法。】
 
         // 这里是提供给子类的扩展点，到这里的时候，所有的 Bean 都加载、注册完成了，但是都还没有初始化
         // 具体的子类可以在这步的时候添加一些特殊的 BeanFactoryPostProcessor 的实现类或做点什么事
         postProcessBeanFactory(beanFactory);
         // 调用 BeanFactoryPostProcessor 各个实现类的 postProcessBeanFactory(factory) 方法
         invokeBeanFactoryPostProcessors(beanFactory);
 
         // 注册 BeanPostProcessor 的实现类，注意看和 BeanFactoryPostProcessor 的区别
         // 此接口两个方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
         // 两个方法分别在 Bean 初始化之前和初始化之后得到执行。注意，到这里 Bean 还没初始化
         registerBeanPostProcessors(beanFactory);
 
         // 初始化当前 ApplicationContext 的 MessageSource，国际化这里就不展开说了，不然没完没了了
         initMessageSource();
 
         // 初始化当前 ApplicationContext 的事件广播器，这里也不展开了
         initApplicationEventMulticaster();
 
         // 从方法名就可以知道，典型的模板方法(钩子方法)，
         // 具体的子类可以在这里初始化一些特殊的 Bean（在初始化 singleton beans 之前）
         onRefresh();
 
         // 注册事件监听器，监听器需要实现 ApplicationListener 接口。这也不是我们的重点，过
         registerListeners();
 
         // 重点，重点，重点
         // 初始化所有的 singleton beans，并将它们放入Spring容器的缓存中（缓存底层为ConcurrentHashMap结构）
         //（lazy-init 的除外）
         finishBeanFactoryInitialization(beanFactory);
 
         // 最后，广播事件，ApplicationContext 初始化完成
         finishRefresh();
      }
 
      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }
 
         // Destroy already created singletons to avoid dangling resources.
         // 销毁已经初始化的 singleton 的 Beans，以免有些 bean 会一直占用资源
         destroyBeans();
 
         // Reset 'active' flag.
         cancelRefresh(ex);
 
         // 把异常往外抛
         throw ex;
      }
 
      finally {
         // Reset common introspection caches in Spring's core, since we
         // might not ever need metadata for singleton beans anymore...
         resetCommonCaches();
      }
   }
}

这里我们重点关注与aop初始化关联的主要逻辑，registerBeanPostProcessor和finishBeanFactoryInitialization。

3.执行registerBeanPostProcessor()

注册后置处理器(只是创建了这个对象：AnnotationAwareAspectJAutoProxyCreator)

4.执行finishBeanFactoryInitialization(beanFactory)

循环实例化所有的未实例化的单例bean：

4.1. 情况一：如果此时的bean是切面类（标注@Aspect）。

4.1.1. 实例化bean之前

->执行resolveBeforeInstantiation->InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
    ...
    beanInstance = this.resolveBeforeInstantiation(beanName, mbdToUse);
    if (beanInstance != null) {
        return beanInstance;
    }
    ...
}
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
        if (!mbd.isSynthetic() && this.hasInstantiationAwareBeanPostProcessors()) {
            Class targetType = this.determineTargetType(beanName, mbd);
            if (targetType != null) {
                //主要进行AbstractAutoProxyCreator.postProcessBeforeInstantiation操作
                bean = this.applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                if (bean != null) {
                    //如果有返回对象（上面返回的是包含切面逻辑的该bean的代理对象），继续执行实例化后置通知方法
                    bean = this.applyBeanPostProcessorsAfterInitialization(bean, beanName);
                }
            }
        }
        mbd.beforeInstantiationResolved = bean != null;
    }
    return bean;
}
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
    Object cacheKey = this.getCacheKey(beanClass, beanName);
    if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
        //advisedBeans用于存储不可代理的bean，如果包含直接返回
        if (this.advisedBeans.containsKey(cacheKey)) {
            return null;
        }
        //判断当前bean是否可以被代理，然后存入advisedBeans
        if (this.isInfrastructureClass(beanClass) || this.shouldSkip(beanClass, beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return null;
        }
    }
    //获取当前bean的TargetSource对象，如果不存在，则直接退出当前方法，否则从TargetSource中获取当前bean对象，并且判断是否需要将切面逻辑应用在当前bean上
    TargetSource targetSource = this.getCustomTargetSource(beanClass, beanName);
    if (targetSource != null) {
        if (StringUtils.hasLength(beanName)) {
            this.targetSourcedBeans.add(beanName);
        }
        // 获取能够应用当前bean的切面逻辑
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
        //创建包含切面逻辑的该bean的代理对象
        Object proxy = this.createProxy(beanClass, beanName, specificInterceptors, targetSource);
        //把生成的代理对象进行缓存
        this.proxyTypes.put(cacheKey, proxy.getClass());
        //返回该代理对象，在上一级方法中，有做后置通知方法的处理
        return proxy;
    } else {
        return null;
    }
}
protected boolean isInfrastructureClass(Class beanClass) {
    return super.isInfrastructureClass(beanClass) || this.aspectJAdvisorFactory != null && this.aspectJAdvisorFactory.isAspect(beanClass);
}
protected boolean isInfrastructureClass(Class beanClass) {
    //如果bean继承自Advice、Pointcut、Advisor、AopInfrastructureBean
    boolean retVal = Advice.class.isAssignableFrom(beanClass) || Pointcut.class.isAssignableFrom(beanClass) || Advisor.class.isAssignableFrom(beanClass) || AopInfrastructureBean.class.isAssignableFrom(beanClass);
    if (retVal && this.logger.isTraceEnabled()) {
        this.logger.trace("Did not attempt to auto-proxy infrastructure class [" + beanClass.getName() + "]");
    }
​
    return retVal;
}
public boolean isAspect(Class clazz) {
    //如果bean带有@Aspect注解，并且不能被Ajc（AspectJ编译器）编译
    return this.hasAspectAnnotation(clazz) && !this.compiledByAjc(clazz);
}

（1）判断当前bean是否在advisedBeans中（保存了所有需要增强bean，使用Boolean区分是否可以被代理。false可以理解为切面类，不需要代理的；如果是true，表示被切的类，表明已经生成过代理了（即切面逻辑已经应用到该bean））；

（2）判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean、判断是否是切面（是否实现了注解@Aspect）、判断是否需要跳过； 注：因为是切面类（标注@Aspect），则会advisedBeans.put(cacheKey, Boolean.FALSE)，加入到增强Bean的map集合中，并返回null，然后到上一级程序继续执行下一步。

（3）如果用户使用了自定义的TargetSource对象，则直接使用该对象生成目标对象，而不会使用Spring的默认逻辑生成目标对象，并且这里会判断各个切面逻辑是否可以应用到当前bean上，如果可以，则直接应用，也就是说TargetSource为使用者在Aop中提供了一个自定义生成目标bean逻辑的方式，并且会应用相应的切面逻辑。即在这一步就已经把切面逻辑应用在了该bean上，并生成了代理对象。在这之后直接返回该bean，createBean方法结束。

4.1.2. 初始化bean之后

->执行doCreateBean->initializeBean->InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization 未作特别处理，可忽略 ->执行doCreateBean->initializeBean->InstantiationAwareBeanPostProcessor.postProcessAfterInitialization->wrapIfNecessary 判断该bean是否需要增强,如果需要增强，则创建一个该bean的代理对象。因为是切面类，所以不需要增强，返回bean

补充：在实例化bean前后使用的后置处理器并不一定是一个，而是会把所有的后置处理器（每个后置处理器方法都有before和after，处理时机不同）都遍历一遍（处理器按照一定顺序）来处理当前的bean。

4.2. 情况二：此时的bean是需要被切的类（即@Pointcut("a.b.c")中a.b.c覆盖到的类）

4.2.1. 实例化bean之前

执行resolveBeforeInstantiation->InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation（执行方法同上面切面类里的方法）

（1）判断当前bean是否在advisedBeans中（保存了所有需要增强bean）；

（2）判断当前bean是否是基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean、判断是否是切面（是否实现了注解@Aspect）、判断是否需要跳过；

（3）如果用户使用了自定义的TargetSource对象，则直接使用该对象生成目标对象，而不会使用Spring的默认逻辑生成目标对象，并且这里会判断各个切面逻辑是否可以应用到当前bean上，如果可以，则直接应用，也就是说TargetSource为使用者在Aop中提供了一个自定义生成目标bean逻辑的方式，并且会应用相应的切面逻辑。

注：因为是需要被切的类，所以以上三个条件都不满足，既不在advisedBeans中，也不是基础类等，更不是自定义的TargetSource对象，所以这个过程未作特别处理，返回null。

4.2.2. 初始化bean之后

->执行doCreateBean->initializeBean->InstantiationAwareBeanPostProcessor.postProcessBeforeInitialization 未作特别处理，可忽略 ->执行doCreateBean->initializeBean->InstantiationAwareBeanPostProcessor.postProcessAfterInitialization->wrapIfNecessary

public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
        if (this.earlyProxyReferences.remove(cacheKey) != bean) {
            return this.wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
​
    return bean;
}
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    //如果是targetSourcedBeans存放已经增强过的bean，则不需要再次处理
    if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
        return bean;
    } else if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
        //advisedBeans的key为cacheKey，value为boolean类型，表示是否进行过代理
        //已经处理过的（切面）bean,不需要再次进行处理，节省时间
        return bean;
    } else if (!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
        //如果不是内部基础设置类Class && 不需要跳过（即配置了该bean需要代理，则不需要跳过）
        Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    } else {
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}

（1）未被增强处理过，且未被代理过，且不是基础方法，且不需要跳过的，才能执行下一步； （2）执行getAdvicesAndAdvisorsForBean，获取当前对象所有适用的Advisor（即切面类实例），主要处理两件事。具体逻辑如下，

protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, @Nullable TargetSource targetSource) {
    List advisors = this.findEligibleAdvisors(beanClass, beanName);
    return advisors.isEmpty() ? DO_NOT_PROXY : advisors.toArray();
}
​
protected List findEligibleAdvisors(Class beanClass, String beanName) {
    //找到Spring中Advisor的实现类（findCandidateAdvisors）
    //将所有拥有@Aspect注解的类转换为advisors（aspectJAdvisorsBuilder.buildAspectJAdvisors）
    List candidateAdvisors = this.findCandidateAdvisors();
    //找到当前对象适合的所有Advisor
    List eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
    //添加一个默认的advisor，执行时用到
    this.extendAdvisors(eligibleAdvisors);
    if (!eligibleAdvisors.isEmpty()) {
        eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
    }
​
    return eligibleAdvisors;
}

第一步，执行findCandidateAdvisors()，其中执行父级findCandidateAdvisors，找到Spring中Advisor的实现类（已经存在的Advisor）；然后执行aspectJAdvisorsBuilder.buildAspectJAdvisors，将所有拥有@Aspect注解的类转换为advisors（转换的过程，其实就是创建Advisor的过程，本质是创建InstantiationModelAwarePointcutAdvisorImpl对象）；最终把所有的切面类实例advisors放到list中。具体逻辑如下，

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

super.findCandidateAdvisors()方法最终调用advisorRetrievalHelper.findAdvisorBeans()，逻辑如下，

public List findAdvisorBeans() {
        String[] advisorNames = this.cachedAdvisorBeanNames;
        if (advisorNames == null) {
            // 获取当前BeanFactory中所有实现了Advisor接口的bean的名称
            advisorNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Advisor.class, true, false);
            this.cachedAdvisorBeanNames = advisorNames;
        }
​
        if (advisorNames.length == 0) {
            return new ArrayList();
        } else {
            List advisors = new ArrayList();
            String[] var3 = advisorNames;
            int var4 = advisorNames.length;
            // 对获取到的实现Advisor接口的bean的名称进行遍历
            for(int var5 = 0; var5 < var4; ++var5) {
                String name = var3[var5];
                // isEligibleBean()是提供的一个hook方法，用于子类对Advisor进行过滤，这里默认返回值都是true
                if (this.isEligibleBean(name)) {
                    // 如果当前bean还在创建过程中，则略过，其创建完成之后会为其判断是否需要织入切面逻辑
                    if (this.beanFactory.isCurrentlyInCreation(name)) {
                        if (logger.isTraceEnabled()) {
                            logger.trace("Skipping currently created advisor '" + name + "'");
                        }
                    } else {
                        try {
                            // 将当前bean添加到advisors结果中
                            advisors.add(this.beanFactory.getBean(name, Advisor.class));
                        } catch (BeanCreationException var11) {
                            // 对获取过程中产生的异常进行封装
                            Throwable rootCause = var11.getMostSpecificCause();
                            if (rootCause instanceof BeanCurrentlyInCreationException) {
                                BeanCreationException bce = (BeanCreationException)rootCause;
                                String bceBeanName = bce.getBeanName();
                                if (bceBeanName != null && this.beanFactory.isCurrentlyInCreation(bceBeanName)) {
                                    if (logger.isTraceEnabled()) {
                                        logger.trace("Skipping advisor '" + name + "' with dependency on currently created bean: " + var11.getMessage());
                                    }
                                    continue;
                                }
                            }
​
                            throw var11;
                        }
                    }
                }
            }
​
            return advisors;
        }
    }

aspectJAdvisorsBuilder.buildAspectJAdvisors()会触发ReflectiveAspectJAdvisorFactory中的getAdvisors方法，逻辑如下，

public List getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
    //从 aspectMetadata 中获取 Aspect()标注的类 class对象
    Class aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
    //获取Aspect()标注的类名
    String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
    this.validate(aspectClass);
    // We need to wrap the MetadataAwareAspectInstanceFactory with a decorator
    // so that it will only instantiate once.
    MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
    List advisors = new ArrayList();
    //遍历该类所有方法，根据方法判断是否能获取到对应 pointCut，如果有，则生成 advisor 对象
    Iterator var6 = this.getAdvisorMethods(aspectClass).iterator();
    while(var6.hasNext()) {
        Method method = (Method)var6.next();
        //这里继续看下面的解析
        Advisor advisor = this.getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }
	// If it's a per target aspect, emit the dummy instantiating aspect.
    if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
        Advisor instantiationAdvisor = new ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
        advisors.add(0, instantiationAdvisor);
    }

    Field[] var12 = aspectClass.getDeclaredFields();
    int var13 = var12.length;
	//获取 @DeclareParents 注解修饰的属性（并不常用）
    for(int var14 = 0; var14 < var13; ++var14) {
        Field field = var12[var14];
        Advisor advisor = this.getDeclareParentsAdvisor(field);
        if (advisor != null) {
            advisors.add(advisor);
        }
    }

    return advisors;
}

getAdvisor的具体逻辑如下，

public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrderInAspect, String aspectName) {
    this.validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
    AspectJExpressionPointcut expressionPointcut = this.getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
    //构建InstantiationModelAwarePointcutAdvisorImpl对象
    return expressionPointcut == null ? null : new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod, this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

InstantiationModelAwarePointcutAdvisorImpl会触发getAdvice，具体逻辑如下，

public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
    ...
    Object springAdvice;
    //根据注解类型，匹配对应的通知类型
    switch(aspectJAnnotation.getAnnotationType()) {
        //切面
        case AtPointcut:
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
            }
​
            return null;
        //环绕通知
        case AtAround:
            springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        //前置通知
        case AtBefore:
            springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        //最终通知
        case AtAfter:
            springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            break;
        //后置（正常）通知
        case AtAfterReturning:
            springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterReturning afterReturningAnnotation = (AfterReturning)aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterReturningAnnotation.returning())) {
                ((AbstractAspectJAdvice)springAdvice).setReturningName(afterReturningAnnotation.returning());
            }
            break;
        //异常通知
        case AtAfterThrowing:
            springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
            AfterThrowing afterThrowingAnnotation = (AfterThrowing)aspectJAnnotation.getAnnotation();
            if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                ((AbstractAspectJAdvice)springAdvice).setThrowingName(afterThrowingAnnotation.throwing());
            }
            break;
        default:
            throw new UnsupportedOperationException("Unsupported advice type on method: " + candidateAdviceMethod);
        }
        ...
        return (Advice)springAdvice;
    }
}

其本质是根据@Aspect类中方法的注解类型，生成对应的advice，并通过通知的构造方法，将通知增强方法，切面表达式传入到通知当中。

第二步，执行findAdvisorsThatCanApply，找到当前对象适合的所有Advisor。整个过程比较简单：遍历所有的advisor，然后查看当前advisor的pointCut是否适用于当前对象，如果是，进入候选队列（其实就是放到一个list中），否则跳过。

（3）执行createProxy，创建代理对象。

具体实现逻辑如下，

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);
    //检查proxyTargeClass设置以及preserveTargetClass属性  
    //决定对于给定的bean是否应该使用targetClass而不是他的接口代理
    if (!proxyFactory.isProxyTargetClass()) {
        if (this.shouldProxyTargetClass(beanClass, beanName)) {
            proxyFactory.setProxyTargetClass(true);
        } else {
            //用来添加代理接口
            this.evaluateProxyInterfaces(beanClass, proxyFactory);
        }
    }

    Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
    //加入增强器
    proxyFactory.addAdvisors(advisors);
    //设置要代理的类
    proxyFactory.setTargetSource(targetSource);
    //定制代理
    this.customizeProxyFactory(proxyFactory);
    //用来控制代理工厂被设置后是否还允许修改通知，缺省值为false
    proxyFactory.setFrozen(this.freezeProxy);
    if (this.advisorsPreFiltered()) {
        proxyFactory.setPreFiltered(true);
    }

    return proxyFactory.getProxy(this.getProxyClassLoader());
}

从上面代码我们看到对于代理类的创建及处理spring是委托给了ProxyFactory处理的，而在此函数中主要是对ProxyFactory的初始化操作，进而对创建代理做准备，这些初始化操作包括以下内容： 第一步，获取当前类中的属性 第二步，添加代理接口

下面是添加代理接口evaluateProxyInterfaces的函数：

protected void evaluateProxyInterfaces(Class beanClass, ProxyFactory proxyFactory) {
    Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.getProxyClassLoader());
    boolean hasReasonableProxyInterface = false;
    Class[] var5 = targetInterfaces;
    int var6 = targetInterfaces.length;
​
    int var7;
    Class ifc;
    for(var7 = 0; var7 < var6; ++var7) {
        ifc = var5[var7];
        if (!this.isConfigurationCallbackInterface(ifc) && !this.isInternalLanguageInterface(ifc) && ifc.getMethods().length > 0) {
            hasReasonableProxyInterface = true;
            break;
        }
    }
​
    if (hasReasonableProxyInterface) {
        var5 = targetInterfaces;
        var6 = targetInterfaces.length;
​
        for(var7 = 0; var7 < var6; ++var7) {
            ifc = var5[var7];
            proxyFactory.addInterface(ifc);
        }
    } else {
        proxyFactory.setProxyTargetClass(true);
    }
​
}

第三步，封装Advisor并加入到ProxyFactory中 ​ 第四步，设置要代理的类 ​ 第五步，在spring中还为子类提供了定制的函数customizeProxyFactory，子类可以在此函数中进行对ProxyFactory的进一步封装 ​ 第六步，进行获取代理操作

上面proxyFactory.getProxy中的createAopProxy()最终调用的是DefaultAopProxyFactory.createAopProxy()的实现逻辑如下，

public Object getProxy(@Nullable ClassLoader classLoader) {
    return this.createAopProxy().getProxy(classLoader);
}
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
        return new JdkDynamicAopProxy(config);
    } else {
        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.");
        } else {
            return (AopProxy)(!targetClass.isInterface() && !Proxy.isProxyClass(targetClass) ? new ObjenesisCglibAopProxy(config) : new JdkDynamicAopProxy(config));
        }
    }
}

注意：如果bean是需要被切的类（如开始举的UserServiceImpl例子），那么在bean缓存池中存放的就是带有切面逻辑的代理对象，该代理对象属性中包含advisors（结构是ArrayList，里面存放的是切点和通知，就是我们常用的@Aspect 注解标记的类），具体参考下面几张结果图，

 

如下可以看出，在beanPostProcessors后置处理器集合中，有AnnotationAwareAspectJAutoProxyCreator对象这里有userServiceImpl这个因被切而生成的代理对象（已经应用了切面逻辑）属性，并且使用的是CGLib代理。

如下图，可以看出在bean缓存池中，存放了userServiceImpl的代理对象（注意没有再单独的userServiceImpl对象了，因为userServiceImpl被切了，所以bean缓存吃中保存的只有userServiceImpl的代理对象），该代理对象下有切点和通知，在后续使用该bean的时候，会用到这里的其切点和通知，会转换成拦截器，并形成拦截器链，保证通知方法按顺序执行。

四、Spring AOP是如何起作用的？

如上面的userServiceImpl，实际存到bean缓存池中存放的就是带有切面逻辑的代理对象，如上的userServiceImpl就是一个cglib代理对象，在执行到该方法的时候，获取到的该bean就是这个cglib代理对象，所以执行他的方法的时候，首先会进入cglib代理对象的拦截器，即CglibAopProxy.intercept()拦截器，其中会获取即将执行的目标方法的拦截器链。具体逻辑如下，

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    Object oldProxy = null;
    boolean setProxyContext = false;
    Object target = null;
    TargetSource targetSource = this.advised.getTargetSource();
​
    Object var16;
    try {
        if (this.advised.exposeProxy) {
            oldProxy = AopContext.setCurrentProxy(proxy);
            setProxyContext = true;
        }
​
        target = targetSource.getTarget();
        Class targetClass = target != null ? target.getClass() : null;
        //根据ProxyFactory对象获取将要执行的目标方法拦截器链
        List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
        Object retVal;
        //如果没有拦截器链，直接执行目标方法
        if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
            Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
            retVal = methodProxy.invoke(target, argsToUse);
        } else {
            //如果有连接器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个CglibMethodInvocation对象
            retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();
        }
​
        retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);
        var16 = retVal;
    } finally {
        if (target != null && !targetSource.isStatic()) {
            targetSource.releaseTarget(target);
        }
​
        if (setProxyContext) {
            AopContext.setCurrentProxy(oldProxy);
        }
​
    }
​
    return var16;
}
public Object proceed() throws Throwable {
    //从-1开始,下标=拦截器的长度-1的条件满足表示执行到了最后一个拦截器的时候，此时执行目标方法
    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
        return this.invokeJoinpoint();
    } else {
        //获取第一个方法拦截器使用的是前++
        Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
            Class targetClass = this.targetClass != null ? this.targetClass : this.method.getDeclaringClass();
            return dm.methodMatcher.matches(this.method, targetClass, this.arguments) ? dm.interceptor.invoke(this) : this.proceed();
        } else {
            return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
        }
    }
} 
  
（1）执行advised.getInterceptorsAndDynamicInterceptionAdvice，
 
  
        1）List interceptionList保存所有拦截器5 一个默认的ExposeInvocationInterceptor 和 4个增强器。
 
  
        2）遍历所有的增强器，将每个增强器转为MethodInterceptor，具体为，每个增强其都执行registry.getInterceptors(advisor)，其流程为：
 
  
如果是MethodInterceptor 直接加入到List集合中；
 
  
如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor；
 
  
转换完成返回MethodInterceptor[]数组。
 
  
        3）如果没有拦截器链，直接执行目标方法; 拦截器链（每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
 
  
        4）如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，并调用 Object retVal = mi.proceed();
 
  
        5）拦截器链的触发过程; 第一步，如果没有拦截器执行执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（指定到了最后一个拦截器）执行目标方法； 第二步，链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行； 拦截器链的机制，保证通知方法与目标方法的执行顺序；
 
  
五、总结
 
  
（1）@EnableAspectJAutoProxy 开启AOP功能，即往bean定义注册表中注册AnnotationAwareAspectJAutoProxyCreator；
 
  
（2）AnnotationAwareAspectJAutoProxyCreator是一个后置处理器，这里提供了获取适用当前bean的切面逻辑，并把切面逻辑应用到该bean，最后创建一个代理对象的所有方法，所以他是spring提供aop功能的核心；
 
  
（3）IOC容器的创建流程（以下为与AOP初始化相关的逻辑）：
 
  
        1）refresh.registerBeanPostProcessors（）注册后置处理器；创建AnnotationAwareAspectJAutoProxyCreator对象
 
  
        2）finishBeanFactoryInitialization（）初始化剩下的单实例bean
 
  
                1.如果是切面类，则advisedBeans.put(cacheKey, Boolean.FALSE)，加入到增强Bean的map集合中；
 
  
                2.如果是自定义的TargetSource对象，则直接使用该对象生成目标对象，而不会使用Spring的默认逻辑生成目标对象，并且这里会判断各个切面逻辑是否可以应用到当前bean上，如果可以，则直接应用，也就是说TargetSource为使用者在Aop中提供了一个自定义生成目标bean逻辑的方式，并且会应用相应的切面逻辑。
 
  
                 3.如果是需要被切的类，则获取当前对象所有适用的Advisor（即切面类实例），并把Advisor应用到该bean，并最终创建一个代理对象，这个过程被成为增强；
 
  
（4）执行目标方法：
 
  
         1）代理对象执行目标方法
 
  
        2）CglibAopProxy.intercept()；
 
  
                 1.得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）
 
  
                2.利用拦截器的链式机制，依次进入每一个拦截器进行执行；
 
  
                3.效果： 正常执行：前置通知-》目标方法-》返回通知-》后置通知 出现异常：前置通知-》目标方法-》异常通知-》后置通知
 
  
（5）AOP中几个重要的概念
 
  
        1）切面（aspect）：类是对物体特征的抽象，切面就是对横切关注点的抽象，在Spring中意为所有通知方法所在的类，如上例中使用@Aspect注解的（LogAspects）切面类。
 
  
        2）连接点（Join point）：被拦截到的点，因为 Spring 只支持方法类型的连接点，所以在 Spring 中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器，如上面被拦截到的userServiceImpl.add方法就是连接点。
 
  
        3）切入点（pointcut）：与通知一起出现，使用专门的切点表达式决定在何处执行通知方法，如上例使用的@Pointcut注解设计到具体类或方法，就是切入点。
 
  
        4）通知（advice）：所谓通知指的就是指拦截到连接点之后要执行的代码，共有5种类型，before（切点之前执行），around（环绕执行，即切点前后执行），After returning（切点正常执行完返回后执行），After throwing（切点抛出异常后执行），after（切点之后执行，不管是异常或正常结束），AOP拦截器链则为以上五种通知组成。我们可以在通知方法中获得我们需要的参数（返回值，异常信息，代理对象等）。
 
  
        5）目标对象（target object）：代理的目标对象，如上例中的UserServiceImpl就是目标对象。
 
  
        6）织入（weaving）：将切面应用到目标对象并导致代理对象创建的过程，Spring AOP是动态织入（运行时织入），AspectJ则是静态织入（编译时织入），如上例执行的wrapIfNecessary方法执行的过程就是织入。
 
  
        7）引入（introduction）：在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或属性，例如，可以使用引入来使一个bean实现isModified接口，以便简化缓存机制。
 
  
        8）AOP代理（AOP proxy）：AOP代理对象，由JDK动态代理或CGLIB代理生成。
 
  
（6）扩展：spring boot中的事务处理，本质跟上面的AOP逻辑类似，
 
  
        1）Sringboot启动类上添加@EnableTransactionManagement，
 
  
@EnableTransactionManagement引入的是TransactionManagementConfigurationSelector。该类引入两个组件，分别是AutoProxyRegistrar和ProxyTransactionManagementConfiguration。
 
  
AutoProxyRegistrar会去创建InfrastructureAdvisorAutoProxyCreator的beandefinition，这个是bean的后置处理器，做的事情和上面的AOP的AnnotationAwareAspectJAutoProxyCreator类似。
 
  
ProxyTransactionManagementConfiguration它是一个配置类，里面包括有一些bean方法，在最后创建bean时，这些beanMethod返回的bean都会创建对象添加到iOC容器。其中包括有： BeanFactoryTransactionAttributeSourceAdvisor、AnnotationTransactionAttributeSource、TransactionInterceptor。作用其实就是个切面类，定义了一些切面逻辑。
 
  
        2）在需要使用事务的方法上加@Transactional，实现事务操作。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring,java,spring,aop,springboot整合aop,IOC,cglib动态代理)

        

            

                
    
                    
  • Android开发
                        哈哈哈隔
android
                        
    AndroidAdapter是将数据绑定到UI界面上的桥接类比如:当lambada中只有一个参数时，可以用it指代@Target和@Retention是由Java提供的元注解，所谓元注解就是标记其他注解的注解，下面分别介绍https://blog.csdn.net/javazejian/article/details/71860633#%E5%A3%B0%E6%98%8E%E6%B3%A8%E8%
    
                    
    • 
                    
  • 大整数加、减法（Java实现）与debug找错
                        gfu_
java算法数据结构
                        
    前言这篇文章主要内容涉及大整数加法的实现以及debug使用的简单记录。以前当我碰到程序报错时，总是想找别人帮忙，感觉debug太难了，自己根本看不懂。这次，自己在做一道算法题时，程序能够运行，结果却出错了。本来想找别人帮忙，但想着学习还是要脚踏实地，于是自己硬着头皮上了，先在网上了解如何debug，然后一步一步找到了错误所在。主要是想记录下第一次debug找到问题的快乐。一、大整数加法（java）
    
                    
    • 
                    
  • Java+Selenium+Cucumber自动化测试框架：高效软件测试的利器
                        测试渣
javaselenium
                        
    一、引言在当今软件开发的快速迭代的背景下，确保软件质量和功能的正确性变得愈发关键。自动化测试作为一种提高测试效率、降低成本的有效手段，受到了广泛的关注。Java作为一门功能强大且广泛应用的编程语言，与Selenium和Cucumber相结合的自动化测试框架，为软件测试领域带来了诸多优势。本文将深入探讨这一自动化测试框架，包括其简介、各组件的作用、环境搭建、实际应用案例以及未来发展趋势等内容。二、J
    
                    
    • 
                    
  • 华为余承东“剧透”新形态手机；自DeepSeek发布以来，英伟达市值已蒸发4200亿美元；Java 24正式发布 | 极客头条
                        极客日报
华为智能手机java
                        
    「极客头条」——技术人员的新闻圈！CSDN的读者朋友们好，「极客头条」来啦，快来看今天都有哪些值得我们技术人关注的重要新闻吧。整理|郑丽媛出品|CSDN（ID：CSDNnews）一分钟速览新闻点！华为余承东“揭秘”新形态手机：不是卷轴屏/伸缩屏，但男生女生都会喜欢腾讯去年营收增长8%，马化腾：重组AI团队，增加AI相关的资本开支金山办公：2024年WPSOffice全球月度活跃设备数达6.32亿，
    
                    
    • 
                    
  • 都快3202年了，你还不会用Java生成计算机统一标识符
                        Heping_Ge2333
java
                        
    Java生成计算机统一标识符计算机统一标识符的概念什么是计算机统一标识符？计算机统一标识符就相当于每台电脑每个系统的“身份证”。它是唯一的。通常，计算机统一标识符是根据电脑的硬件情况（主板、cpu的序列号，mac地址）和系统情况（windows/linux/unix）生成的。Java语言的实现下面这段代码浅浅的实现了计算机统一标识符importlombok.Data;importlombok.ex
    
                    
    • 
                    
  • Java IO流详解
                        我真的不想做程序员
java文件读写java开发语言后端数据结构算法
                        
    目录一、JavaIO流基础（一）字节流常见字节流类（二）字符流常见字符流类二、字节流操作示例（一）读取文件（二）写入文件（三）带缓冲功能的字节流三、字符流操作示例（一）读取文件（二）写入文件（三）带缓冲功能的字符流四、总结一、JavaIO流基础JavaIO流用于处理设备之间的数据传输，主要包括字节流和字符流两大类。字节流以字节为单位进行数据传输，适用于处理二进制数据；字符流以字符为单位进行传输，适
    
                    
    • 
                    
  • Optional源码解析和示例解析
                        飞翔中文网
Java开发语言javajdk
                        
    Optional源码解析packagejava.util;importjava.util.function.Consumer;importjava.util.function.Function;importjava.util.function.Predicate;importjava.util.function.Supplier;/***这是一个容器对象，它可能包含一个非空值，也可能不包含。*如果
    
                    
    • 
                    
  • 2025React岗位前端面试题180道及其答案解析,看完稳了,万字长文,持续更新....
                        祈澈菇凉
前端
                        
    1.什么是React？它的主要特点是什么？答案解析：React是一个用于构建用户界面的JavaScript库，主要用于构建单页应用。其主要特点包括：组件化：React应用由多个可重用的组件组成，便于管理和维护。虚拟DOM：React使用虚拟DOM提高性能，通过最小化实际DOM操作来优化渲染过程。单向数据流：数据在组件之间以单向流动的方式传递，简化了数据管理和调试。声明式编程：React允许开发者以
    
                    
    • 
                    
  • 书籍-《优化基础：理论、工具及应用（论文版）》
                        
机器学习人工智能
                        
    书籍：OptimizationEssentials:Theory,Tools,andApplications作者：FaizHamid出版：Springer编辑：陈萍萍的公主@一点人工一点智能下载：书籍下载-《优化基础：理论、工具及应用（论文版）》01书籍介绍本书探讨了运筹学和数学优化领域的最新发展和令人兴奋的挑战。它以统一且精心编排的方式呈现了以下内容：(a)现实生活中出现的新颖优化问题，并突出每
    
                    
    • 
                    
  • Python前端开发
                        PITSU
正则表达式htmlcss3mysql
                        
    Python前端开发1.前端三剑客（HTML，CSS和JavaScript）1.1HTML1.1.1HTML简介HyperTextMark-upLanguage,指的是超文本标记语言；html是开发网页的语言；html中的标签大多数都是成对出现的,格式:1.1.2HTML结构第一行是文档声明部分HTML：分为页头，页身和页脚。标签大部分是成对出现1.1.3第一行文档声明部分HTML在vscode中
    
                    
    • 
                    
  • java毕业设计，在线水果商城系统
                        爱编程的小哥
java毕设java课程设计springbootvue
                        
    天天生鲜在线商城系统技术解密|SpringBoot+Vue3企业级实战（附高并发场景解决方案）一、系统全景解读该系统是生鲜电商全流程解决方案，采用SpringBoot3+Vue3+ElementPlus技术栈，覆盖商品管理、智能分类、订单处理、用户画像等核心场景，通过RBAC权限控制+OSS图片存储+高并发库存管理三大技术亮点，日均支撑5000+商品、10万+订单的电商需求。系统以蓝白清新界面+实
    
                    
    • 
                    
  • springboot整合mybatis分页插件不生效问题
                        潘 令
springbootmybatisjava后端
                        
    原因分析做项目时发现导入分页插件的场景启动器后，分页插件不生效，一直查询出所有数据上网搜索发现分页插件不生效主要有以下原因：1、没有导入分页插件的场景启动器，而是导入了普通的分页插件依赖com.github.pagehelperpagehelper5.1.10导入该依赖后还需要进行额外的配置1).在MyBatis配置xml中配置拦截器插件<propertyname="param1&
    
                    
    • 
                    
  • 计算机专业毕业设计题目推荐（新颖选题）本科计算机科学专业相关毕业设计选题大全✅
                        会写代码的羊
毕设选题课程设计计算机网络毕设选题毕设系统毕设题目计算机科学专业
                        
    文章目录前言最新毕设选题（建议收藏起来）本科计算机科学专业相关的毕业设计选题毕设作品推荐前言2025全新毕业设计项目博主介绍：✌全网粉丝10W+,CSDN全栈领域优质创作者，博客之星、掘金/华为云/阿里云等平台优质作者。技术范围：SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、大数据、机器学习等设计与开发。主要内容：免费功能设计
    
                    
    • 
                    
  • RabbitMQ中如何确保你的消息只被消费一次
                        昔我往昔
MQrabbitmqruby分布式
                        
    在SpringBoot项目中，确保RabbitMQ消息只被消费一次是一个常见且重要的问题。为了确保消息在RabbitMQ中只被消费一次，我们通常依赖于消息确认机制（acknowledgment），以及幂等性设计。以下是一些常见的做法来实现这一目标。1.使用消息确认机制（Ack）RabbitMQ提供了消息确认机制，允许消费者在成功处理消息后通知RabbitMQ服务器。这可以确保在消息消费完成前，不会
    
                    
    • 
                    
  • 物联网 - JetLinks与ThingsBoard技术选型对比
                        天机️灵韵
物联网开源项目物联网
                        
    JetLinks与ThingsBoard作为两款主流的开源物联网平台，在技术架构、功能特性及适用场景上存在显著差异。以下从技术选型的关键维度进行深度对比分析：JetLinks与ThingsBoard物联网平台的深度技术对比及选型建议，综合多个维度分析两者的核心差异与适用场景：一、技术架构与性能技术栈JetLinks：基于Java8、SpringBoot2.x、WebFlux、Netty等，采用响应
    
                    
    • 
                    
  • 使用Java实现Oracle表结构转换为PostgreSQL的示例方案(AI)
                        秉承初心
AI创造javaoraclepostgresql
                        
    核心代码importjava.sql.*;importjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;importjava.util.Map;publicclassOracleToPGConverter{//类型映射表privatestaticfinalMapTYPE_MAPPING=newHashMapcolumn
    
                    
    • 
                    
  • Java并发编程之ReentrantReadWriteLock
                        Johnny Lnex
Java并发编程java开发语言jvm
                        
    基本使用方法创建锁对象首先，通过newReentrantReadWriteLock()创建一个锁实例。获取读锁和写锁使用readLock()方法获得读锁对象，使用writeLock()方法获得写锁对象。使用锁保护共享资源在需要保护的代码块前后分别调用lock()和unlock()方法，确保对共享资源的访问安全。示例代码：importjava.util.concurrent.locks.Reentr
    
                    
    • 
                    
  • java中如何根据已有word文件快速生成目录和页码？
                        bug菌¹
全栈Bug调优(实战版)javawordpython生成目录生成页码文件操作
                        
    本文收录于《全栈Bug调优(实战版)》专栏，主要记录项目实战过程中所遇到的Bug或因后果及提供真实有效的解决方案，希望能够助你一臂之力，帮你早日登顶实现财富自由；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！全文目录：问题描述解决方案优化基于Docx4j的TOC生成性能问题及日志警告解决方案**1.性能优化****1.1避免使用FOP渲染获取页码****1.2使用更高效的文档
    
                    
    • 
                    
  • java 离线语音_Java通过JNA&麦克风调离线语音唤醒
                        不吃芹菜的鸭梨君
java离线语音
                        
    packagecom.day.iFlyInterface.commonUtil.dll.ivw;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.IOException;importjava.util.Arrays;importjavax.sound.
    
                    
    • 
                    
  • springBoot中myBatisPlus的使用
                        无足鸟丶
springboot后端java
                        
    MyBatis-Plus是一个MyBatis的增强工具，在SpringBoot项目里使用它能极大提升开发效率。下面为你详细介绍在SpringBoot中使用MyBatis-Plus的步骤以及示例代码。1.创建SpringBoot项目你可以借助SpringInitializr（https://start.spring.io/）来创建一个新的SpringBoot项目，添加以下依赖：SpringWebSp
    
                    
    • 
                    
  • springBoot中不添加依赖 , 手动生成一个token ,并校验token (使用简单 , 但是安全会低一点)
                        无足鸟丶
springboot安全后端
                        
    在SpringBoot里，即便不添加额外依赖，也能手动生成和校验Token。下面以简单的基于时间戳和密钥的方式来生成和校验Token为例，介绍具体实现步骤。实现思路生成Token：把用户信息、时间戳等数据组合起来，再用密钥进行哈希处理，生成一个唯一的Token。校验Token：从Token里提取出用户信息和时间戳，重新进行哈希处理，然后与原Token进行对比，同时检查时间戳是否过期。代码实现1.创
    
                    
    • 
                    
  • 2023第十四届蓝桥杯Java大学生C组真题？（真题+附链接）
                        大C爱编程
蓝桥杯java算法
                        
    第十四届蓝桥杯大赛软件赛省赛Java大学A组试题A:求和本题总分：5分【问题描述】求1（含）至20230408（含）中每个数的和。【答案提交】这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。试题B:分糖果本题总分：5分【问题描述】两种糖果分别有9个和16个，要全部分给7个小朋友，每个小朋友得到的糖果总数最少为2个最多为5
    
                    
    • 
                    
  • java-生成二维码，并写入word尾页【基础篇】
                        橙-极纪元JJYCheng
javaword开发语言
                        
    java-生成二维码，并写入word尾页【基础篇】介绍项目框架：SpringBoot项目管理：Maven推荐文章1：java-生成二维码，二维码增加logo，读取二维码推荐文章2：java-生成二维码，并写入word尾页【基础篇】推荐文章3：java-生成二维码，并写入word尾页【高级篇】推荐文章4：java
    
                    
    • 
                    
  • 【总结篇】java多线程,新建线程有几种写法,以及每种写法的优劣势
                        橙-极纪元JJYCheng
java免费文章java开发语言java多线程新建线程有几种写法
                        
    java多线程新建线程有几种写法,以及每种写法的优劣势[1/5]java多线程新建线程有几种写法–继承Thread类以及他的优劣势[2/5]java多线程-新建线程有几种写法–实现Runnable接口以及他的优劣势[3/5]java多线程新建线程有几种写法–实现Callable接口结合FutureTask使用以及他的优劣势[4/5]java多线程新建线程有几种写法–利用Executor框架以及他的
    
                    
    • 
                    
  • Linux篇1-初识Linux
                        逃跑的机械工
Linuxlinux
                        
    1.Linux能干什么Linux能够进行各种语言的开发工作，基本主要以后端语言为主C++，JAVA,python;Linux能进行各种指令操作，从而完成各种的文件相关的管理工作2.Linux基本指令2.1ls指令在Linux中，以.开头的文件，叫做隐藏文件；ls-a显示隐藏文件隐藏文件：Linux配置文件，可以隐藏起来，防止误操作，起到保护作用；ls-l列出文件的详细信息-d将目录象文件一样显示，
    
                    
    • 
                    
  • 【开题报告+论文+源码】基于SpringBoot+Vue的社区团购配送系统
                        编程毕设
springboot后端java
                        
    项目背景与意义随着社会的进步和收入的提高，消费者对购物体验有了更高的要求。他们希望获得更多样化的商品选择，更加便捷的购物方式，以及更加优质的售后服务。同时，越来越多的老年人开始关注健康饮食和食品质量。他们不再满足于传统的购物方式，而是希望通过更加方便的方式来获取更加安全和健康的食品。社区团购配送系统在满足用户日常生活需求的同时，也带来了许多便利和机遇。项目介绍本课程演示的是一款基于SpringBo
    
                    
    • 
                    
  • 10 分钟学会SpringValidation数据校验和全局异常处理
                        ohn.yu
springspringbootjava
                        
    以下是一个使用Spring开发的简单RESTAPI小程序，通过对一张user表进行操作，代码演示如何RestAPI开发中实现数据校验、全局异常处理和返回Json格式数据。使用的核心框架包括SpringBootSpringWebSpringDataJPABeanValidation（JSR-303）Lombok1.项目依赖（pom.xml）创建一个Maven项目，添加以下依赖："xmlns:xsi=
    
                    
    • 
                    
  • Java设计模式之代理模式
                        飞翔中文网
Javajava设计模式
                        
    概念和作用代理模式是一种结构型设计模式，它允许为其他对象提供一种代理以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介作用，可以在目标对象执行某些操作前后添加额外的功能。使用场景1.访问控制：根据用户权限决定是否允许访问目标对象。2.日志记录：在访问目标对象前后记录日志信息。3.性能监控：测量目标对象方法的执行时间。4.延迟加载：按需加载资源，避免过早占用内存。举例静态代理静态代理在编
    
                    
    • 
                    
  • 若依框架入门指南：快速上手SpringBoot+前后端分离版
                        小小鸭程序员
springjavaspringboot后端intellij-idea
                        
    若依（RuoYi）是一款基于SpringBoot的快速开发平台，集成了权限管理、代码生成、监控管理等功能。本文将以SpringBoot+Vue前后端分离版本为例，带你快速上手若依框架。一、环境准备基础环境：JDK1.8+MySQL5.7+Redis5.0+Maven3.6+Node.js14+（前端）下载项目：#后端项目gitclonehttps://gitee.com/y_project/Ruo
    
                    
    • 
                    
  • 在Ubuntu上安装MEAN Stack的4个步骤
                        
ubuntu
                        
    在Ubuntu上安装MEANStack的4个步骤为：1.安装MEAN；2.安装MongoDB；3.安装NodeJS，Git和NPM；4.安装剩余的依赖项。什么是MEANStack？平均堆栈一直在很大程度上升高为基于稳健的基于JavaScript的开发堆栈。名称的意思是指其组件;MongoDB，ExpressJS，Angularjs和NodeJS。第1步：安装MEAN对于此安装，我们将在本指南中使用
    
                    
    • 
                                
  • 微信开发者验证接口开发
                                    362217990
微信 开发者 token 验证
                                    
    微信开发者接口验证。 
Token，自己随便定义，与微信填写一致就可以了。 
 
根据微信接入指南描述 http://mp.weixin.qq.com/wiki/17/2d4265491f12608cd170a95559800f2d.html 
 第一步：填写服务器配置 
 第二步：验证服务器地址的有效性 
 第三步：依据接口文档实现业务逻辑 
 
这里主要讲第二步验证服务器有效性。 
 
建一个
    
                                
    • 
                                
  • 一个小编程题-类似约瑟夫环问题
                                    BrokenDreams
编程
                                    
            今天群友出了一题： 
        一个数列,把第一个元素删除,然后把第二个元素放到数列的最后,依次操作下去,直到把数列中所有的数都删除,要求依次打印出这个过程中删除的数。 
 
     &
    
                                
    • 
                                
  • linux复习笔记之bash shell (5) 关于减号-的作用
                                    eksliang
linux关于减号“-”的含义linux关于减号“-”的用途linux关于“-”的含义linux关于减号的含义
                                    
        转载请出自出处：
http://eksliang.iteye.com/blog/2105677     
    管道命令在bash的连续处理程序中是相当重要的，尤其在使用到前一个命令的studout（标准输出）作为这次的stdin（标准输入）时，就显得太重要了，某些命令需要用到文件名，例如上篇文档的的切割命令（split）、还有
    
                                
    • 
                                
  • Unix(3)
                                    18289753290
unix ksh
                                    
    1)若该变量需要在其他子进程执行，则可用"$变量名称"或${变量}累加内容 
什么是子进程？在我目前这个shell情况下，去打开一个新的shell，新的那个shell就是子进程。一般状态下，父进程的自定义变量是无法在子进程内使用的，但通过export将变量变成环境变量后就能够在子进程里面应用了。 
2)条件判断： &&代表and  ||代表or&nbs
    
                                
    • 
                                
  • 关于ListView中性能优化中图片加载问题
                                    酷的飞上天空
ListView
                                    
    ListView的性能优化网上很多信息，但是涉及到异步加载图片问题就会出现问题。 
具体参看上篇文章http://314858770.iteye.com/admin/blogs/1217594 
  
如果每次都重新inflate一个新的View出来肯定会造成性能损失严重，可能会出现listview滚动是很卡的情况，还会出现内存溢出。 
现在想出一个方法就是每次都添加一个标识，然后设置图
    
                                
    • 
                                
  • 德国总理默多克：给国人的一堂“震撼教育”课
                                    永夜-极光
教育
                                    
    http://bbs.voc.com.cn/topic-2443617-1-1.html德国总理默多克：给国人的一堂“震撼教育”课　 
安吉拉—默克尔，一位经历过社会主义的东德人，她利用自己的博客，发表一番来华前的谈话，该说的话，都在上面说了，全世界想看想传播——去看看默克尔总理的博客吧！ 
　　德国总理默克尔以她的低调、朴素、谦和、平易近人等品格给国人留下了深刻印象。她以实际行动为中国人上了一堂
    
                                
    • 
                                
  • 关于Java继承的一个小问题。。。
                                    随便小屋
java
                                    
    今天看Java 编程思想的时候遇见一个问题，运行的结果和自己想想的完全不一样。先把代码贴出来！ 
//CanFight接口
interface Canfight {
    void fight();
}
//ActionCharacter类
class ActionCharacter {
    public void fight() {
        System.out.pr
    
                                
    • 
                                
  • 23种基本的设计模式
                                    aijuans
设计模式
                                    
    Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。  　　Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。  　　Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。  　　Builder：将一个复杂对象的构建与它的表示分离，使得同
    
                                
    • 
                                
  • 《周鸿祎自述：我的互联网方法论》读书笔记
                                    aoyouzi
读书笔记
                                    
    从用户的角度来看,能解决问题的产品才是好产品,能方便/快速地解决问题的产品,就是一流产品. 
  
商业模式不是赚钱模式 
一款产品免费获得海量用户后,它的边际成本趋于0,然后再通过广告或者增值服务的方式赚钱,实际上就是创造了新的价值链. 
  
商业模式的基础是用户,木有用户,任何商业模式都是浮云.商业模式的核心是产品,本质是通过产品为用户创造价值. 
商业模式还包括寻找需求
    
                                
    • 
                                
  • JavaScript动态改变样式访问技术
                                    百合不是茶
JavaScriptstyle属性ClassName属性
                                    
      
一:style属性 
格式:  
 HTML元素.style.样式属性="值"; 
  
创建菜单:在html标签中创建 或者 在head标签中用数组创建 
  
<html>
<head>
  <title>style改变样式</title>
</head>
&l
    
                                
    • 
                                
  • jQuery的deferred对象详解
                                    bijian1013
jquerydeferred对象
                                    
            jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。 
        每个版本都会引入一些新功能，从jQuery 1.5.0版本开始引入的一个新功能----deferred对象。 
   &nb
    
                                
    • 
                                
  • 淘宝开放平台TOP
                                    Bill_chen
C++c物流C#
                                    
    淘宝网开放平台首页：http://open.taobao.com/ 
淘宝开放平台是淘宝TOP团队的产品，TOP即TaoBao Open Platform， 
是淘宝合作伙伴开发、发布、交易其服务的平台。 
支撑TOP的三条主线为： 
   1.开放数据和业务流程 
 
    * 以API数据形式开放商品、交易、物流等业务； 
 
 &
    
                                
    • 
                                
  • 【大型网站架构一】大型网站架构概述
                                    bit1129
网站架构
                                    
    大型互联网特点 
 
 面对海量用户、海量数据 
 大型互联网架构的关键指标 
 
 高并发 
 高性能 
 高可用 
 高可扩展性 
 线性伸缩性 
 安全性 
 大型互联网技术要点 
  
 
 前端优化 
 CDN缓存 
 反向代理 
 KV缓存 
 消息系统 
 分布式存储 
 NoSQL数据库 
 搜索 
 监控 
 安全 
 想到的问题： 
1.对于订单系统这种事务型系统，如
    
                                
    • 
                                
  • eclipse插件hibernate tools安装
                                    白糖_
Hibernate
                                    
      
 
 eclipse helios(3.6)版 
  1.启动eclipse   2.选择 Help > Install New Software...>   3.添加如下地址： 
http://download.jboss.org/jbosstools/updates/stable/helios/   4.选择性安装：hibernate tools在All Jboss tool
    
                                
    • 
                                
  • Jquery easyui Form表单提交注意事项
                                    bozch
jquery easyui
                                    
    jquery easyui对表单的提交进行了封装，提交的方式采用的是ajax的方式，在开发的时候应该注意的事项如下： 
        1、在定义form标签的时候，要将method属性设置成post或者get，特别是进行大字段的文本信息提交的时候，要将method设置成post方式提交，否则页面会抛出跨域访问等异常。所以这个要
    
                                
    • 
                                
  • Trie tree(字典树)的Java实现及其应用-统计以某字符串为前缀的单词的数量
                                    bylijinnan
java实现
                                    
    
import java.util.LinkedList;

public class CaseInsensitiveTrie {

	/**
	字典树的Java实现。实现了插入、查询以及深度优先遍历。 
    Trie tree's java implementation.(Insert,Search,DFS)
    
	Problem Description
	Igna
    
                                
    • 
                                
  • html css 鼠标形状样式汇总
                                    chenbowen00
htmlcss
                                    
    css鼠标手型cursor中hand与pointer  
Example：CSS鼠标手型效果 <a href="#" style="cursor:hand">CSS鼠标手型效果</a><br/>  
Example：CSS鼠标手型效果 <a href="#" style=&qu
    
                                
    • 
                                
  • [IT与投资]IT投资的几个原则
                                    comsci
it
                                    
     
      无论是想在电商,软件,硬件还是互联网领域投资,都需要大量资金,虽然各个国家政府在媒体上都给予大家承诺,既要让市场的流动性宽松,又要保持经济的高速增长....但是,事实上,整个市场和社会对于真正的资金投入是非常渴望的,也就是说,表面上看起来,市场很活跃,但是投入的资金并不是很充足的...... 
 
   
    
                                
    • 
                                
  • oracle with语句详解
                                    daizj
oraclewithwith as
                                    
    oracle with语句详解 转 
 
 
在oracle中，select 查询语句，可以使用with,就是一个子查询，oracle 会把子查询的结果放到临时表中，可以反复使用 
 
例子:注意，这是sql语句，不是pl/sql语句， 可以直接放到jdbc执行的 
 
----------------------------------------------------------------
    
                                
    • 
                                
  • hbase的简单操作
                                    deng520159
数据库hbase
                                    
    近期公司用hbase来存储日志,然后再来分析 ,把hbase开发经常要用的命令找了出来. 
用ssh登陆安装hbase那台linux后 
用hbase shell进行hbase命令控制台! 
表的管理 
1）查看有哪些表 
hbase(main)> list 
2）创建表 
  
# 语法：create <table>, {NAME => <family&g
    
                                
    • 
                                
  • C语言scanf继续学习、算术运算符学习和逻辑运算符
                                    dcj3sjt126com
c
                                    
    /*
	2013年3月11日20:37:32
	地点：北京潘家园
	功能：完成用户格式化输入多个值
	目的：学习scanf函数的使用

*/
# include <stdio.h>

int main(void)
{
	int i, j, k;

	printf("please input three number:\n");  //提示用
    
                                
    • 
                                
  • 2015越来越好
                                    dcj3sjt126com
歌曲
                                    
    越来越好

房子大了电话小了 感觉越来越好
假期多了收入高了 工作越来越好
商品精了价格活了 心情越来越好
天更蓝了水更清了 环境越来越好

活得有奔头人会步步高
想做到你要努力去做到

幸福的笑容天天挂眉梢 越来越好
婆媳和了家庭暖了 生活越来越好
孩子高了懂事多了 学习越来越好
朋友多了心相通了 大家越来越好
道路宽了心气顺了 日子越来越好

活的有精神人就不显
    
                                
    • 
                                
  • java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Tim
                                    feiteyizu
mysql
                                    
    数据表中有记录的time字段（属性为timestamp）其值为：“0000-00-00 00:00:00” 
程序使用select 语句从中取数据时出现以下异常： 
java.sql.SQLException:Value '0000-00-00' can not be represented as java.sql.Date 
  
java.sql.SQLException: Valu
    
                                
    • 
                                
  • Ehcache（07）——Ehcache对并发的支持
                                    234390216
并发ehcache锁ReadLockWriteLock
                                    
    Ehcache对并发的支持 
  
       在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同
    
                                
    • 
                                
  • mysql中blob,text字段的合成索引
                                    jackyrong
mysql
                                    
      在mysql中，原来有一个叫合成索引的，可以提高blob,text字段的效率性能， 
但只能用在精确查询，核心是增加一个列，然后可以用md5进行散列，用散列值查找 
则速度快 
 
比如： 
 
create table abc(id varchar(10),context blog,hash_value varchar(40)); 
 
 insert into abc(1,rep
    
                                
    • 
                                
  • 逻辑运算与移位运算
                                    latty
位运算逻辑运算
                                    
    源码：正数的补码与原码相同例+7 源码：00000111 补码 ：00000111  （用8位二进制表示一个数）
 
 
 
负数的补码：
   符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。   -7 源码： 10000111 ，其绝对值为00000111  取反加一：11111001 为-7补码 
 
已知一个数的补码，求原码的操作分两种情况：
    
                                
    • 
                                
  • 利用XSD 验证XML文件
                                    newerdragon
javaxmlxsd
                                    
    XSD文件 （XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。 具体使用方法和定义请参看： 
 
http://www.w3school.com.cn/schema/index.asp 
 
 
 
java自jdk1.5以上新增了SchemaFactory类 可以实现对XSD验证的支持，使用起来也很方便。 
 
以下代码可用在J
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(12) - Samba
                                    rensanning
centos
                                    
    （1）安装 
 
# yum -y install samba
    Installed:
      samba.i686 0:3.6.9-169.el6_5
# pdbedit -a rensn
    new password:123456
    retype new password:123456
    …… 
 
 
（2）Home文件夹 
 
# mkdir /etc
    
                                
    • 
                                
  • Learn Nodejs 01
                                    toknowme
nodejs
                                    
    （1）下载nodejs  
https://nodejs.org/download/   选择相应的版本进行下载           （2）安装nodejs   安装的方式比较多，请baidu下  
我这边下载的是“node-v0.12.7-linux-x64.tar.gz”这个版本  （1）上传服务器   （2）解压   tar -zxvf  node-v0.12.
    
                                
    • 
                                
  • jquery控制自动刷新的代码举例
                                    xp9802
jquery
                                    
    1、html内容部分   复制代码代码示例:   <div id='log_reload'> 
<select name="id_s" size="1"> 
<option value='2'>-2s-</option> 
<option value='3'>-3s-</option
    
                                
    •