Spring源码分析（一） 从Spring Bean的生命周期谈起

Spring Bean的生命周期真的是面试的时候关于Spring的最高频的考点之一了，笔者曾经被这个问题问懵了不止一次，一直记不住那一大串的步骤，但实际上尝试去死记硬背那些步骤的我是错误的，表面上看只是背诵一个流程，实际上，这个流程牵扯到的知识点可是很多而且很有意思的。

下面这个图我想很多人应该都看过相同的或者相似的：

Spring Bean的生命周期

看起来还是挺长的对吧，但是我们其实可以把它划分成下面四个大的步骤：

  1. 实例化Bean
  2. 设置对象属性，依赖注入
  3. 初始化
  4. destroy：bean的销毁

接下来，我会根据这个步骤，一步步的讲解相关的知识点，从生命周期出发，将Spring中重要的类或接口来一一说明。

一、实例化Bean

这第一步，容器通过获取BeanDefinition对象中的信息进行实例化。并且这一步仅仅是简单的实例化，并未进行依赖注入，可以理解成new xx()。但要注意的是，对于BeanFactory容器和ApplicationContext容器它们的实例化是有区别的。

  • 对于BeanFactory容器，当客户向容器请求一个尚未初始化的bean时，或初始化bean的时候需要注入另一个尚未初始化的依赖时，容器就会调用createBean()进行实例化。
  • 对于ApplicationContext容器，当容器启动结束后，便实例化所有的bean。

那么既然提到了BeanFactory和ApplicationContext，我就对这两个接口也简单介绍一下。它们分别位于org.springframework.beans和org.springframework.context两个包下，而这两个包，正是Spring IoC容器的基础。BeanFactory提供了框架最基础的一些功能，包括IOC的配置机制，提供Bean的各种定义，建立Bean之间的依赖关系等。ApplicationContext继承了BeanFactory，因此它拥有BeanFactory的所有功能，但它本身还继承了一些其他的接口，比如消息资源配置，事件发布等。

BeanFactory是Spring框架的基础设施，面向Spring。ApplicationContext面向Spring框架的开发者。所以我们平常开发的过程中其实也可以发现到，我们更多的会用上的是ApplicationContext相关的工具，而不是BeanFactory。

除此之外，在实例化这个步骤的前后，实际上还有隐藏任务，牵扯到的接口叫做InstantiationAwareBeanPostProcessor。它继承了BeanPostProcessor。可能有的人不知道BeanPostProcessor这个接口，那么我就先介绍下这个。

BeanPostProcessor也是位于org.springframework.beans下，又叫做后置处理器，它定义了一系列的回调方法用来让使用者可以自定义Bean实例化或者依赖解析等的逻辑。它本身只有两个方法: postProcessBeforeInitialization和postProcessAfterInitialization。如方法名所说，定义Bean的初始化前后的逻辑。这个接口在整个生命周期中都有着关联。

public interface BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Nullable
    default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

不要弄混了BeanPostProcessor中的方法我说的是初始化前后，而生命周期的第一步是实例化。这里用到的InstantiationAwareBeanPostProcessor它有自己的对于实例化逻辑处理的两个方法。postProcessBeforeInstantiation和postProcessAfterInstantiation。

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
    @Nullable
    default Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        return null;
    }

    default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        return true;
    }

    @Nullable
    default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
        return null;
    }
}

通过查找调用postProcessBeforeInstantiation这个方法的地方，会追溯到创建Bean的关键方法。就是AbstractAutowireCapableBeanFactory下的createBean()。

/**
 * Central method of this class: creates a bean instance,
 * populates the bean instance, applies post-processors, etc.
 * @see #doCreateBean
 */
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
    // 里面的代码我下面挑出重点的步骤一步步的贴出来
}

通过查看源码对于此方法的注释就知道它有多重要了。它可以创建Bean的实例，对其进行属性填充，调用BeanPostProcesser等。第一步我们注意到的代码应该是

Class resolvedClass = resolveBeanClass(mbd, beanName);

它实际上是比我们上面生命周期的图示还要之前的一步，就是获取BeanDefinition对象中的信息来对Bean class进行解析。所谓BeanDefinition，它就是对于Bean的一个描述。它包含了Bean的一些基础信息，如Bean的name、Bean的作用域、和其他Bean的关系等等。解析完之后再进行到下一步。

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
  return bean;
}

这个注释其实也给出了它的意义了，它给予BeanPostProcessor们一个机会，可以返回一个代理而不是目标bean的实例。但我们翻阅到上面的InstantiationAwareBeanPostProcessor对于此方法的实现，会发现它返回的是null，所以默认的逻辑这里是不会return的。所以我们会走到下一步，doCreateBean。

Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
   logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;

进入到这个方法，它的第一行注释也是简单粗暴，就是来实例化Bean的。

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
   instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
   instanceWrapper = createBeanInstance(beanName, mbd, args);
}

但可以发现，createBeanInstance()这个方法返回的是一个BeanWrapper对象。BeanWrapper是对Bean的一个包装，它可以设置获取被包装的对象，获取被包装bean的属性描述器等。我们平时开发是不会直接使用这个类的。通过createBeanInstance()这个方法的注释我们也能明白，它的作用是对于指定的bean生成一个新的实例，这里可以使用合适的实例化策略，比如工厂方法，构造器注入或者简单实例化等。

    /**
     * Create a new instance for the specified bean, using an appropriate instantiation strategy:
     * factory method, constructor autowiring, or simple instantiation.
     */
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    //代码我也不贴了
  }

接下来这段代码，注释也有说明，就是将调用各种postProcessers来进行属性的合并，这里会进行一些注解的扫描。

// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
   if (!mbd.postProcessed) {
      try {
         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Post-processing of merged bean definition failed", ex);
      }
      mbd.postProcessed = true;
   }
}

再然后是一段跟一个面试题紧密相关的代码，那就是Spring如何解决循环依赖。因为本文的重点是讲bean的生命周期，本来准备一起写完的，但写着写着发现要说的太多了，后面我会另外单独写文章来讲述如何解决循环依赖的问题。

// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isTraceEnabled()) {
      logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

二、设置对象属性，依赖注入

结束了实例化之后，我们继续在createBean这个方法上继续往下走，到了populateBean这一步。

// Initialize the bean instance.
Object exposedObject = bean;
try {
   populateBean(beanName, mbd, instanceWrapper);
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
   if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
      throw (BeanCreationException) ex;
   }
   else {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
   }
}

对于这个方法，我们已开始注意到的就是我之前说过在实例化前后都是存在着隐藏任务，上面提到了实例化之前的postProcessBeforeInstantiation，那么如今已经实例化了，现在出现了实例化之后的方法postProcessAfterInstantiation，这里也是给InstantiationAwareBeanPostProcessors一个机会去自定义属性被赋值后的方式。在后面代码中回去执行这个后置处理器的方法。

// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
      if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
         return;
      }
   }
}

继续往下，我们能看到一个熟悉的单词，Autowire，不过这里是获取当前注入的方式，根据byName还是byType来获得要注入的属性。这里我也不深入说明了。

PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

int resolvedAutowireMode = mbd.getResolvedAutowireMode();
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
   MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
   // Add property values based on autowire by name if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
      autowireByName(beanName, mbd, bw, newPvs);
   }
   // Add property values based on autowire by type if applicable.
   if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
      autowireByType(beanName, mbd, bw, newPvs);
   }
   pvs = newPvs;
}

然后就是populateBean的第一步我就提到的方法，如果存在后置处理器，那么会进行属性的校验和处理，同时第二个布尔变量是用来判断是否进行依赖校验的。

boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
   }
   for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
      PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
      if (pvsToUse == null) {
         if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
         }
         pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
            return;
         }
      }
      pvs = pvsToUse;
   }
}
if (needsDepCheck) {
   if (filteredPds == null) {
      filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
   }
   checkDependencies(beanName, mbd, filteredPds, pvs);
}

最后一步，就是将前面这些步骤得到的属性进行注入了。

if (pvs != null) {
   applyPropertyValues(beanName, mbd, bw, pvs);
}

三、初始化

populateBean()方法结束后开始进入initializeBean()方法，正如方法名所表达的，就是bean的初始化。注意初始化和实例化不是一个意思，在生命周期中bean是先进行实例化再进行初始化的。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
} 
 
首先第一步，先不管那些安全机制的代码，我们要关注的是invokeAwareMethods(beanName, bean);这行代码，这里就是调用所有的Aware类型的接口。Spring中Aware类型的接口可以让我们获取容器中的一些资源。
 
 
private void invokeAwareMethods(String beanName, Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}
 
 
比如这里面出现的有三种Aware类型的接口: BeanNameAware, BeanClassLoaderAware,BeanFactoryAware。它们根据bean实现了某个接口来完成不同的工作。
 
 
     
  
  • 如果实现了BeanNameAware接口，则通过setBeanName()方法将beanName设置给这个bean
    •  
  
  • 如果实现了BeanClassLoaderAware接口，则通过setBeanClassLoader()方法，将ClassLoader传入
    •  
  
  • 如果实现了BeanFactoryAware接口，则通过setBeanFactory()方法，将BeanFactory容器实例传入
    •  
 
 
 
结束完Aware接口的调用，继续往下走，到了applyBeanPostProcessorsBeforeInitialization()这个方法（因为if判断是这个bean是空或者这个bean是否是synthetic的，就是是否是应用自己定义的，显然我们自己的bean不是，所以if条件后半部分会是true）。这个方法就是处理我之前有提到过的BeanPostProcessor的postProcessBeforeInitialization()方法。如果Bean实现了BeanPostProcessor接口，那么就会执行这个方法。
 
 
之后，流程来到了invokeInitMethods()这一步，这一步就是执行bean的自定义初始化方法。如果bean实现了InitializingBean接口，就需要重写afterPropertiesSet()方法，则invokeInitMethods的时候会调用这个重写后的afterPropertiesSet()方法，如果bean自定义了init方法，则会调用指定的init方法（可通过xml中配置bean的init-method属性实现），这两个方法的先后顺序是: afterPropertiesSet在前，自定义init在后。
 
 
继续下去就是applyBeanPostProcessorsAfterInitialization()方法了，和前面的applyBeanPostProcessorsBeforeInitialization()方法前后呼应，这个就不必多说了。
 
 
四、销毁
 
 
后面的一段代码还是跟处理循环依赖有关系，就先不多说，直接到最后一步，registerDisposableBeanIfNecessary().
 
 
销毁这一步其实就是可以让我们自己自定义bean的销毁方法，用到的关键的接口是DisposableBean，它和InitializingBean接口类似，只是一个初始化阶段的init，一个是结束阶段的destroy。
 
 
/**
 * Add the given bean to the list of disposable beans in this factory,
 * registering its DisposableBean interface and/or the given destroy method
 * to be called on factory shutdown (if applicable). Only applies to singletons.
 * @param beanName the name of the bean
 * @param bean the bean instance
 * @param mbd the bean definition for the bean
 * @see RootBeanDefinition#isSingleton
 * @see RootBeanDefinition#getDependsOn
 * @see #registerDisposableBean
 * @see #registerDependentBean
 */
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
   AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
   if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
      if (mbd.isSingleton()) {
         // Register a DisposableBean implementation that performs all destruction
         // work for the given bean: DestructionAwareBeanPostProcessors,
         // DisposableBean interface, custom destroy method.
         registerDisposableBean(beanName, new DisposableBeanAdapter(
               bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
      }
      else {
         // A bean with a custom scope...
         Scope scope = this.scopes.get(mbd.getScope());
         if (scope == null) {
            throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
         }
         scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(
               bean, beanName, mbd, getBeanPostProcessorCache().destructionAware, acc));
      }
   }
}
 
 
代码示例
 
 
上面一大段一大段的源码可能看着让人有点难受，不如直接写个demo轻松一下。因为只是表现一下生命周期，那么我们的依赖就很简单，spring-context和spring-beans即可。
 
 

    org.springframework
    spring-context
    5.2.9.RELEASE


    org.springframework
    spring-beans
    5.2.9.RELEASE

 
 
我们先定义一个自定义的后置处理器，为了表现初始化前后和实例化前后的流程，实现InstantiationAwareBeanPostProcessor接口，并重写postProcessBeforeInstantiation()/postProcessAfterInstantiation()/postProcessBeforeInitialization()/postProcessAfterInitialization()这四个方法。
 
 
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
        System.out.println(beanName + "实例化前");
        return null;
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println(beanName + "实例化后");
        return false;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName + "初始化前");
        return null;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName + "初始化后");
        return null;
    }

}
 
 
再定义一个“常规”的Bean，但我们也为了反应初始化和销毁的几个操作，让他实现了InitializingBean, DisposableBean, BeanNameAware三个接口。并实现对应的方法，Aware接口这里我就只实现一个了，只是为了表现注入Aware接口那个步骤。
 
 
public class DemoBean implements InitializingBean, DisposableBean, BeanNameAware {

    public DemoBean() {
        System.out.println("demoBean实例化");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("demoBean afterPropertiesSet");
    }

    public void init() {
        System.out.println("demoBean init");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("demoBean destroy");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware setBeanName: "+ s);
    }
}
 
 
配置文件很简单，就两个bean。
 
 



    
        
        
        
    

 
 
测试类也很简单粗暴，就单纯启动和结束。
 
 
public class Test {

    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:application.xml");
        applicationContext.registerShutdownHook();
    }
}
 
 
点击运行，接下来就是意料之中的结果输出:
 
 
测试结果
 
 
因为属性注入不方便在这里面进行测试，但大家知道是在实例化和初始化之间就好。所以其实总的来说，Spring的生命周期理解起来不算很难，但大家对生命周期里面关键的接口或者类要有印象，ApplicationContext和BeanFactory就不用多说，BeanPostProcessor是一定要知道的，Spring中的很多功能的实现都跟其有关。比如@Autowired注解的原理，数据校验Validate的原理，都是有对应的处理器。
 
 
这篇博客写了我挺久的时间，就是越写发现自己对Spring的了解越浅薄，本以为啃完了Spring文档的我应该是能轻松看懂源码，但实际上还是有点吃力的，但看懂了之后真的神清气爽，后面还会继续在这个坑里多填一点东西，学到的越多发现不会的越多，一起进步吧。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(javaspring)

        

            

                
    
                    
  • 【数据库学习】Flyway
                        兔兔西
数据库学习数据库学习之postgres数据库
                        
    1，功能数据库版本管理；实现管理并跟踪数据库变更，支持数据库版本自动升级。2，使用1）java使用添加依赖org.flywaydbflyway-core6.5.7配置：javaspring:flyway:#是否启用enabled:true#可以支持多个location,用','隔开locations:classpath:db/migration#是否创建元数据表validate-on-migrat
    
                    
    • 
                    
  • Spring是怎样处理循环依赖的？
                        后端开发萌新
死磕Spring源码系列springjava
                        
    文章目录环境前言什么是循环依赖？所有注入场景的循环依赖Spring都能解决吗？场景TestA.javaTestB.javaspring-context.xmlMain.java测试结果Spring是怎么解决循环依赖的？前置说明源码解析addSingletonFactorygetSingletongetEarlyBeanReference总结环境SpringFrameworkVersion：5.3.
    
                    
    • 
                    
  • 【JavaSpring】为什么使用sring以及其中的bean线程安全吗？spring支持几种bean作用域和自动装配bean哪些方式？spring事务隔离？mvc运行流程
                        王果冻ddd
安全springmvcjava开发语言
                        
    目录1、为什么要使用spring？2、spring中的bean是线程安全的吗？3、spring支持几种bean的作用域？4、spring自动装配bean有哪些方式？5、spring事务实现方式有哪些？6、说一下spring的事务隔离？7、说一下springmvc运行流程？1、为什么要使用spring？•spring提供ioc技术，容器会帮你管理依赖的对象，从而不需要自己创建和管理依赖对象了，更轻松
    
                    
    • 
                    
  • JavaSpring-AOP详解（Maven导入 深入浅出）
                        GarsonW
软件开发springjava
                        
    在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。目录通过Maven仓库导入相关依赖AOP（开始）AOP术语AOP五种通知AOP相同切入点的抽取有多个增强类对同一个同一个方法进行增强通过Maven仓库导入相关依赖文件结构：pom.xml:4.0.0comGarson
    
                    
    • 
                    
  • 85道Java Spring综合面试题详解含答案（值得珍藏）
                        孤蓬&听雨
面试资料javaspring开发语言面试
                        
    点击下载《85道JavaSpring综合面试题详解含答案（值得珍藏）》1.Spring概述1.1什么是spring?Spring是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。1.2使用Spring框架的好处是什么？轻量：S
    
                    
    • 
                    
  • 深入理解Java Spring中的全局异常处理：以Reggie项目为例
                        hoypte
javaspring状态模式
                        
    在JavaSpring开发中，异常处理是非常关键的一部分。优雅地处理异常不仅可以提升用户体验，还能帮助开发者快速定位问题。本文将通过Reggie项目中的一个实例，深入探讨如何在Spring中使用@ControllerAdvice和@ExceptionHandler实现全局异常处理。项目背景Reggie是一个基于Spring框架的Web应用，它可能包含多个控制器（Controller）来处理不同的业
    
                    
    • 
                    
  • Java Spring注解——Controller层、Service层、mapper层
                        千Deng
java开发语言
                        
    目录前言一、Controller层常用注解（一）写在类名上方（二）写在类内部二、Service层常用注解三、mapper层常用注解四、lombok注解（一）用于实体类（二）用于类对象后续敬请期待前言JavaSpring注解——Controller层、Service层、mapper层等一、Controller层常用注解（一）写在类名上方@RestController@RestController可将
    
                    
    • 
                    
  • SpringBoot动态切换数据源
                        陆卿之
springboot后端java
                        
    文章目录SpringBoot动态切换数据源数据库添加依赖配置数据源信息TestUser.javaTestUserMapper.java方式一（ThreadLocal）DynamicDataSourceContextHolder.javaDynamicRoutingDataSource.javaDynamicDataSourceConfig.javaTestController.javaSpring
    
                    
    • 
                    
  • Java Spring框架基础教程
                        C红毛丹
javaspring开发语言
                        
    1.引言JavaSpring框架是一个轻量级的、开源的应用程序框架，用于开发Java应用程序。它提供了一种简化和加速Java应用程序开发的方式，同时也提供了一些强大的功能和特性。本教程将介绍JavaSpring框架的基础知识和使用方法，帮助读者快速上手并理解该框架的核心概念。2.Spring框架概述Spring框架由RodJohnson于2002年创建，最初是为了解决企业级应用程序开发中的一些常见
    
                    
    • 
                    
  • @Scheduled注解 定时任务讲解
                        蓝胖子不是胖子
springbootspring
                        
    用于在JavaSpring框架中定时执行特定任务的注解@Scheduled，它能够指定方法在特定时间间隔或特定时间点执行。默认参数是cron，cron参数被用来定义一个Cron表达式，它代表了任务执行的时间规则参数如下Cron这是是一种时间表达式，用于表示定时任务的执行规则。在Spring中，@Scheduled注解的cron参数就是用来设置Cron表达式的。Cron表达式的基本格式为：secdo
    
                    
    • 
                    
  • Spring Boot Serverless 实战 | Serverless 应用的监控与调试
                        阿里云云栖号
云栖号技术分享springbootserverlessjava
                        
    简介：SpringBoot是基于JavaSpring框架的套件，它预装了Spring的一系列组件，让开发者只需要很少的配置就可以创建独立运行的应用程序。在云原生的环境中，有大量的平台可以运行SpringBoot应用，例如虚拟机、容器等。但其中最有吸引力的，是以Serverless的方式运行SpringBoot应用。作者：西流SpringBoot是基于JavaSpring框架的套件，它预装了Spri
    
                    
    • 
                    
  • security登录实战
                        Stephen_CY666
java
                        
    以下是一个基本的security登录实战代码示例，采用JavaSpring框架：配置security@Configuration@EnableWebSecuritypublicclassSecurityConfigextendsWebSecurityConfigurerAdapter{@AutowiredprivateUserDetailServiceImpluserDetailsService;
    
                    
    • 
                    
  • JavaSpring使用Quartz任务调度定时器
                        美渊科技
java
                        
    Quartz任务调度是什么Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz是一个完全由Java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能，但就其简易形式看，你会发现它易用得简直让人受不了！摘自百度百科其实，他还是没有解释明白，我简单说一
    
                    
    • 
                    
  • Spring实战(第4版)pdf
                        weixin_30619101
java开发工具后端
                        
    下载地址：网盘下载Spring实战（第4版）是非常畅销的Spring图书也是国内读者极其熟悉的Spring经典图书之一，Javaweb开发从入门到精通，了解JavaSpring技术内幕。全球有超过100000的开发者使用本书来学习Spring中文版累计销售超10万册，畅销经典Spring技术图书，针对Spring4全新升级作者CraigWalls，SpringSource的软件开发人员，也是一位畅
    
                    
    • 
                    
  • 【主流技术】Redis 在 Spring 框架中的实践
                        手术刀呀

                        
    前言在JavaSpring项目中，数据与远程数据库的频繁交互对服务器的内存消耗比较大，而Redis的特性可以有效解决这样的问题。Redis的几个特性：Redis以内存作为数据存储介质，读写数据的效率极高；Redis支持key-value等多种数据结构，提供字符串，哈希，列表，队列，集合结构直接存取于内存，可持久化（RDB和AOF）；支持主从模式，可以配置集群。下面，我将和大家一起学习分享Redis
    
                    
    • 
                    
  • [学习][笔记]设计模式（基于C/C++实现）＜八＞工厂模式
                        二进制怪兽
设计模式设计模式
                        
    文章目录工厂模式简单工厂模式定义使用场景基本思路实例总结工厂方法模式定义使用场景基本思路实例总结抽象工厂模式定义使用场景基本思路实例总结工厂总结模板工厂模式定义使用场景基本思路实例总结产品注册模板类+单例工厂模板类定义使用场景基本思路实例总结对于javaSpring工厂模式思考总结工厂模式C++深入浅出工厂模式（初识篇）C++深入浅出工厂模式（进阶篇）这种类型的设计模式属于创建型模式，它提供了一种
    
                    
    • 
                    
  • Centos安装RabbitMQ，JavaSpring发送RabbitMQ延迟延时消息，JavaSpring消费RabbitMQ消息
                        胡子哥502
javaMQcentosrabbitmqjava延迟消息
                        
    1，版本说明erlang和rabbitmq版本说明https://www.rabbitmq.com/which-erlang.html确认需要安装的mq版本以及对应的erlang版本。2，下载安装文件RabbitMQ下载地址：https://packagecloud.io/rabbitmq/rabbitmq-serverErlang下载地址：https://packagecloud.io/rabb
    
                    
    • 
                    
  • 【Javaspring学习笔记】动态代理
                        hwj729748198
JavaspringJavaspring学习笔记
                        
    在学习Spring的时候，我们知道Spring主要有两大思想，一个是IOC，另一个就是AOP，对于IOC，依赖注入就不用多说了，而对于Spring的核心AOP来说，我们不但要知道怎么通过AOP来满足的我们的功能，我们更需要学习的是其底层是怎么样的一个原理，而AOP的原理就是java的动态代理机制，所以本篇随笔就是对java的动态机制进行一个回顾。动态代理有两种方式：1、jdk动态代理是由java内
    
                    
    • 
                    
  • 从零开始认识并操纵Spring Aop事务
                        Automn

                        
    [TOC]声明：从零开始，并不代表你对javaSpring一点都不懂的程度哈，本实例只是过一个概貌，详细内容会分多篇文章拆解业务介绍要想要设计一个和事务操作相关的业务，我们以最经典的转账的例子来描述转账，即两个用户之间钱的关系变动，但要求总和不变版本声明本案例使用的Web版本2.5，Spring版本为4.3开发工具为eclipse操作步骤导包Spring各版本官方包下载下载的包包含Spring包以
    
                    
    • 
                    
  • Spring源码：占位符${}解析源码分析
                        mumubili
springPropertySource属性配置javaspringspringboot
                        
    目录1.Spring中用到的占位符解析类2.PropertySourcesPlaceholderConfigurer实现bean工厂后处理器3.PropertyPlaceholderHelper帮助类解析逻辑在javaspring项目中，我们经常使用到${}占位符实现属性值的获取，最常见的就是使用@Value("${propsKey}")的方式完成bean属性值的注入，如下：@Value("${a
    
                    
    • 
                    
  • 基于JavaSpring的学生宿舍管理系统
                        柒月玖.
Javajava
                        
    点击以下链接获取源码：https://download.csdn.net/download/qq_64505944/88407844
    
                    
    • 
                    
  • Java Spring拦截器优化实践: 专注于API路径拦截
                        猫头虎
已解决的Bug专区Spring全家桶技术专区javaspring开发语言
                        
    博主猫头虎带您GotoNewWorld.✨博客首页——猫头虎的博客《面试题大全专栏》文章图文并茂生动形象简单易学！欢迎大家来踩踩~《IDEA开发秘籍专栏》学会IDEA常用操作，工作效率翻倍~《100天精通Golang(基础入门篇）》学会Golang语言，畅玩云原生，走遍大小厂~希望本文能够给您带来一定的帮助文章粗浅，敬请批评指正！文章目录JavaSpring拦截器优化实践:专注于API路径拦截摘要
    
                    
    • 
                    
  • 处理multipart形式的数据
                        losspm

                        
    前言由于本人接触最多的是电子商城的开发，目前涉及到的接口数据处理最多的为字符串，少部分为图片，因此处理大型文件的经验比较少。在学习JavaSpring过程中，了解到JavaSpring处理数据过程中有很多值得学习的地方。就拿multipart来说，Spring为multipart提供了很多扩展性的配置，能够针对不同的业务场景进行相关配置multipart对于表单提交，multipart格式的数据会
    
                    
    • 
                    
  • golang工程——gRpc 拦截器及原理
                        咚伢
golang后端
                        
    oauth2认证与拦截器类似javaspring中的拦截器。gRpc也有拦截器的说法，拦截器可作用于客户端请求，服务端请求。对请求进行拦截，进行业务上的一些封装校验等，类似一个中间件的作用拦截器类型一元请求拦截器流式请求拦截器链式拦截器（一个个调用对应处理函数）使用场景：拦截器可以从元数据获取一些认证进行进行校验。服务端拦截器拦截器定义interceptor.gopackageserverimpo
    
                    
    • 
                    
  • layui+java spring 实现图片文件新增到数据库
                        Luffe船长
javalayuispring
                        
    项目场景：layui+javaspring实现图片文件新增到数据库解决方案：1.首先layui是个不再更新的网址有想了解的可以浏览官网表格组件table-Layui文档2.官网内有专门的组件代码直接粘过来即可Demo单图片上传多图片上传预览图：layui.use(function(){varupload=layui.upload;varlayer=layui.layer;varelement=la
    
                    
    • 
                    
  • 你真的需要微服务?
                        whyreal

                        
    原文我们已经设计和构建了十多年的软件，大部分时间我们一直在使用优秀的Symfony框架来实现这一目标。Symfony是一个传统的PHP组件集，受JavaSpring的启发，我们发现它非常适合作为我们的企业Web应用程序和数字产品的快速开发。然而，去年发布的Symfony4代表了该框架的重点逐渐变化;趋向于微服务方法，这种方法在过去几年中越来越受欢迎。为了说明这种转变，新版本宣称“微服务优先”，Sy
    
                    
    • 
                    
  • 【JavaSpring】Aop的通知类型，获取数据
                        岩塘
JavaSpringjava前端开发语言
                        
    AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置前置通知@Pointcut("execution(voidorg.example.dao.BookDao.update())")privatevoidpt(){}@Before("pt()")publicvoidbefore(){System.out.println("beforeadvice");}后
    
                    
    • 
                    
  • 【JavaSpring】Aop案例
                        岩塘
java开发语言
                        
    测定接口执行效率描述：在接口执行前输出当前系统时间开发模式：XMLor注解思路分析：1.导入坐标（pom.xml）org.aspectjaspectjweaver1.9.4org.springframeworkspring-context5.2.25.RELEASEjunitjunit3.8.1test2.制作连接点的方法（原始操作）packageorg.example.dao;publicint
    
                    
    • 
                    
  • 【JavaSpring】Aop切入点表达式
                        岩塘
java开发语言
                        
    语法格式切入点：要进行增强的方法切入点表达式：要进行增强的方法的描述方式标准格式：动作关键词（访问修饰符【可省略】返回值包名.类名.方法名（参数）异常名【可省略】）描述方法一（描述接口）execution("execution(voidorg.example.dao.BookDao.update())")描述方法二（描述实现类）execution("execution(voidorg.exampl
    
                    
    • 
                    
  • 计算机专业毕业设计项目推荐06-工作室管理系统（Java+Vue+Mysql）
                        一个小肥羊
课程设计javavue.js
                        
    工作室管理系统（JavaSpring+Vue+Mysql）**介绍****系统总体开发情况-功能模块****各部分模块实现****最后想说的****联系方式**介绍本系列(后期可能博主会统一为专栏)博文献给即将毕业的计算机专业同学们,因为博主自身本科和硕士也是科班出生,所以也比较了解计算机专业的毕业设计流程以及模式，在编写的过程中可以说几乎是参照毕业设计目录样式来进行的.博主分享的基本都是自己接触
    
                    
    • 
                                
  • linux系统服务器下jsp传参数乱码
                                    3213213333332132
javajsplinuxwindowsxml
                                    
    在一次解决乱码问题中， 发现jsp在windows下用js原生的方法进行编码没有问题，但是到了linux下就有问题， escape,encodeURI,encodeURIComponent等都解决不了问题 
但是我想了下既然原生的方法不行，我用el标签的方式对中文参数进行加密解密总该可以吧。于是用了java的java.net.URLDecoder,结果还是乱码，最后在绝望之际，用了下面的方法解决了
    
                                
    • 
                                
  • Spring 注解区别以及应用
                                    BlueSkator
spring
                                    
    1. @Autowired 
@Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean，或者不存在UserDao类型的bean，会抛出 BeanCreationException异常，这时可以通过在该属性上再加一个@Qualifier注解来声明唯一的id解决问题。 
  
2. @Qualifier 
当spring中存在至少一个匹
    
                                
    • 
                                
  • printf和sprintf的应用
                                    dcj3sjt126com
PHPsprintfprintf
                                    
    <?php
printf('b: %b <br>c: %c <br>d: %d <bf>f: %f', 80,80, 80, 80);
echo '<br />';
printf('%0.2f <br>%+d <br>%0.2f <br>', 8, 8, 1235.456);

printf('th
    
                                
    • 
                                
  • config.getInitParameter
                                    171815164
parameter
                                    
    web.xml 
 
 <servlet>
  	<servlet-name>servlet1</servlet-name>
  	<jsp-file>/index.jsp</jsp-file>
  	<init-param>
  		<param-name>str</param-name>

    
                                
    • 
                                
  • Ant标签详解--基础操作
                                    g21121
ant
                                    
            Ant的一些核心概念： 
        build.xml：构建文件是以XML 文件来描述的，默认构建文件名为build.xml。        project：每个构建文
    
                                
    • 
                                
  • [简单]代码片段_数据合并
                                    53873039oycg
代码
                                    
            合并规则:删除家长phone为空的记录,若一个家长对应多个孩子,保留一条家长记录,家长id修改为phone,对应关系也要修改。 
        代码如下: 
       
    
                                
    • 
                                
  • java 通信技术
                                    云端月影
Java 远程通信技术
                                    
    在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来
    
                                
    • 
                                
  • string与StringBuilder 性能差距到底有多大
                                    aijuans

                                    
      
        之前也看过一些对string与StringBuilder的性能分析，总感觉这个应该对整体性能不会产生多大的影响，所以就一直没有关注这块！ 
        由于学程序初期最先接触的string拼接，所以就一直没改变过自己的习惯！ 
        
    
                                
    • 
                                
  • 今天碰到 java.util.ConcurrentModificationException 异常
                                    antonyup_2006
java多线程工作IBM
                                    
    今天改bug，其中有个实现是要对map进行循环，然后有删除操作，代码如下： 

Iterator<ListItem> iter = ItemMap.keySet.iterator();
while(iter.hasNext()){
ListItem it = iter.next();
//...一些逻辑操作
ItemMap.remove(it);
}
 
结果运行报Con
    
                                
    • 
                                
  • PL/SQL的类型和JDBC操作数据库
                                    百合不是茶
PL/SQL表标量类型游标PL/SQL记录
                                    
    PL/SQL的标量类型: 
   字符,数字,时间,布尔,%type五中类型的 
--标量：数据库中预定义类型的变量
--定义一个变长字符串 
v_ename varchar2(10); 

--定义一个小数,范围 -9999.99~9999.99 
v_sal number(6,2); 

--定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号 

    
                                
    • 
                                
  • Mockito：一个强大的用于 Java 开发的模拟测试框架实例
                                    bijian1013
mockito单元测试
                                    
    Mockito框架： 
        Mockito是一个基于MIT协议的开源java测试框架。         Mockito区别于其他模拟框架的地方主要是允许开发者在没有建立“预期”时验证被测系统的行为。对于mock对象的一个评价是测试系统的测
    
                                
    • 
                                
  • 精通Oracle10编程SQL(10)处理例外
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *处理例外
 */
--例外简介
--处理例外-传递例外
declare
   v_ename emp.ename%TYPE;
begin
   SELECT ename INTO v_ename FROM emp
      where empno=&no;
   dbms_output.put_line('雇员名：'||v_ename);
exceptio
    
                                
    • 
                                
  • 【Java】Java执行远程机器上Linux命令
                                    bit1129
linux命令
                                    
    Java使用ethz通过ssh2执行远程机器Linux上命令， 
  
封装定义Linux机器的环境信息 
  
package com.tom;


import java.io.File;

public class Env {
    private String hostaddr; //Linux机器的IP地址
    private Integer po
    
                                
    • 
                                
  • java通信之Socket通信基础
                                    白糖_
javasocket网络协议
                                    
    正处于网络环境下的两个程序，它们之间通过一个交互的连接来实现数据通信。每一个连接的通信端叫做一个Socket。一个完整的Socket通信程序应该包含以下几个步骤： 
①创建Socket； 
②打开连接到Socket的输入输出流； 
④按照一定的协议对Socket进行读写操作； 
④关闭Socket。 
  
Socket通信分两部分：服务器端和客户端。服务器端必须优先启动，然后等待soc
    
                                
    • 
                                
  • angular.bind
                                    boyitech
AngularJSangular.bindAngularJS APIbind
                                    
    angular.bind   描述：           上下文，函数以及参数动态绑定，返回值为绑定之后的函数. 其中args是可选的动态参数，self在fn中使用this调用。    使用方法：            angular.bind(se
    
                                
    • 
                                
  • java-13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;


public class KickOutBadGuys {

	/**
	 * 题目：13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。
	 * Maybe you can find out 
    
                                
    • 
                                
  • Redis.conf配置文件及相关项说明（自查备用）
                                    Kai_Ge
redis
                                    
       Redis.conf配置文件及相关项说明 
# Redis configuration file example
 
# Note on units: when memory size is needed, it is possible to specifiy
# it in the usual form of 1k 5GB 4M and so forth:
#

    
                                
    • 
                                
  • [强人工智能]实现大规模拓扑分析是实现强人工智能的前奏
                                    comsci
人工智能
                                    
     
 
     真不好意思,各位朋友...博客再次更新... 
 
     节点数量太少,网络的分析和处理能力肯定不足,在面对机器人控制的需求方面,显得力不从心.... 
 
     但是,节点数太多,对拓扑数据处理的要求又很高,设计目标也很高,实现起来难度颇大... 
 
    
                                
    • 
                                
  • 记录一些常用的函数
                                    dai_lm
java
                                    
    
public static String convertInputStreamToString(InputStream is) {

	StringBuilder result = new StringBuilder();

	if (is != null)
		try {
			InputStreamReader inputReader = new InputStreamRead
    
                                
    • 
                                
  • Hadoop中小规模集群的并行计算缺陷
                                    datamachine
mapreducehadoop并行计算
                                    
    注：写这篇文章的初衷是因为Hadoop炒得有点太热，很多用户现有数据规模并不适用于Hadoop，但迫于扩容压力和去IOE（Hadoop的廉价扩展的确非常有吸引力）而尝试。尝试永远是件正确的事儿，但有时候不用太突进，可以调优或调需求，发挥现有系统的最大效用为上策。 
 
-----------------------------------------------------------------
    
                                
    • 
                                
  • 小学4年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    egg  蛋 
twenty 二十 
any 任何 
well 健康的，好 
  
twelve 十二 
farm 农场 
every 每一个 
back 向后，回 
  
fast 快速的 
whose 谁的 
much 许多 
flower 花 
  
watch 手表 
very 非常，很 
sport 运动 
Chinese 中国的 
  
    
                                
    • 
                                
  • 自己实践了github的webhooks, linux上面的权限需要注意
                                    dcj3sjt126com
githubwebhook
                                    
    环境, 阿里云服务器 
  
1. 本地创建项目, push到github服务器上面 
  
2. 生成www用户的密钥 
sudo -u www ssh-keygen -t rsa -C "[email protected]" 
  
  
3. 将密钥添加到github帐号的SSH_KEYS里面 
  
3. 用www用户执行克隆, 源使
    
                                
    • 
                                
  • Java冒泡排序
                                    蕃薯耀
冒泡排序Java冒泡排序Java排序
                                    
    冒泡排序 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月23日 10:40:14 星期二 
http://fanshuyao.iteye.com/
    
                                
    • 
                                
  • Excle读取数据转换为实体List【基于apache-poi】
                                    hanqunfeng
apache
                                    
    1.依赖apache-poi 
  
2.支持xls和xlsx 
  
3.支持按属性名称绑定数据值 
  
4.支持从指定行、列开始读取 
  
5.支持同时读取多个sheet 
  
6.具体使用方式参见org.cpframework.utils.excelreader.CP_ExcelReaderUtilTest.java 
比如： 
Str
    
                                
    • 
                                
  • 3个处于草稿阶段的Javascript API介绍
                                    jackyrong
JavaScript
                                    
    原文： 
http://www.sitepoint.com/3-new-javascript-apis-may-want-follow/?utm_source=html5weekly&utm_medium=email 
 
 
  本文中，介绍3个仍然处于草稿阶段，但应该值得关注的Javascript API. 
 
1) Web Alarm API 
  &
    
                                
    • 
                                
  • 6个创建Web应用程序的高效PHP框架
                                    lampcy
Web框架PHP
                                    
    以下是创建Web应用程序的PHP框架，有coder bay网站整理推荐： 
1. CakePHP 
CakePHP是一个PHP快速开发框架，它提供了一个用于开发、维护和部署应用程序的可扩展体系。CakePHP使用了众所周知的设计模式，如MVC和ORM，降低了开发成本，并减少了开发人员写代码的工作量。 
2. CodeIgniter 
CodeIgniter是一个非常小且功能强大的PHP框架，适合需
    
                                
    • 
                                
  • 评"救市后中国股市新乱象泛起"谣言
                                    nannan408

                                    
    首先来看百度百家一位易姓作者的新闻： 
 

    三个多星期来股市持续暴跌，跌得投资者及上市公司都处于极度的恐慌和焦虑中，都要寻找自保及规避风险的方式。面对股市之危机，政府突然进入市场救市，希望以此来重建市场信心，以此来扭转股市持续暴跌的预期。而政府进入市场后，由于市场运作方式发生了巨大变化，投资者及上市公司为了自保及为了应对这种变化，中国股市新的乱象也自然产生。

首先，中国股市这两天
    
                                
    • 
                                
  • 页面全屏遮罩的实现 方式
                                    Rainbow702
htmlcss遮罩mask
                                    
    之前做了一个页面，在点击了某个按钮之后，要求页面出现一个全屏遮罩，一开始使用了position:absolute来实现的。当时因为画面大小是固定的，不可以resize的，所以，没有发现问题。 
最近用了同样的做法做了一个遮罩，但是画面是可以进行resize的，所以就发现了一个问题，当画面被reisze到浏览器出现了滚动条的时候，就发现，用absolute 的做法是有问题的。后来改成fixed定位就
    
                                
    • 
                                
  • 关于angularjs的点滴
                                    tntxia
AngularJS
                                    
      
angular是一个新兴的JS框架，和以往的框架不同的事，Angularjs更注重于js的建模，管理，同时也提供大量的组件帮助用户组建商业化程序，是一种值得研究的JS框架。 
  
Angularjs使我们可以使用MVC的模式来写JS。Angularjs现在由谷歌来维护。 
  
这里我们来简单的探讨一下它的应用。 
  
首先使用Angularjs我
    
                                
    • 
                                
  • Nutz--->>反复新建ioc容器的后果
                                    xiaoxiao1992428
DAOmvcIOCnutz
                                    
    问题： 
public class DaoZ { 
  
  public static Dao dao() { // 每当需要使用dao的时候就取一次 
    Ioc ioc = new NutIoc(new JsonLoader("dao.js")); 
    return ioc.get(
    
                                
    •