星仔学习
星仔学习

深入解析Spring原理

IOC的基础 
下面我们从IOC/AOP开始，它们是Spring平台实现的核心部分；虽然，我们一开始大多只是在这个层面上，做一些配置和外部特性的使用工作，但对这两个核心模块工作原理和运作机制的理解，对深入理解Spring平台，却是至关重要的；因为，它们同时也是Spring其他模块实现的基础。从Spring要做到的目标，也就是从简化Java EE开发的出发点来看，简单的来说，它是通过对POJO开发的支持，来具体实现的；具体的说，Spring通过为应用开发提供基于POJO的开发模式，把应用开发和复杂的Java EE服务，实现解耦，并通过提高单元测试的覆盖率，从而有效的提高整个应用的开发质量。这样一来，实际上，就需要把为POJO提供支持的，各种Java EE服务支持抽象到应用平台中去，去封装起来；而这种封装功能的实现，在Spring中，就是由IOC容器以及AOP来具体提供的，这两个模块，在很大程度上，体现了Spring作为应用开发平台的核心价值。它们的实现，是Rod.Johnson在他的另一本著作《Expert One-on-One J2EE Development without EJB》 中，所提到Without EJB设计思想的体现；同时也深刻的体现了Spring背后的设计理念。 

从更深一点的技术层面上来看，因为Spring是一个基于Java语言的应用平台，如果我们能够对Java计算模型，比如像JVM虚拟机实现技术的基本原理有一些了解，会让我们对Spring实现的理解，更加的深入，这些JVM虚拟机的特性使用，包括像反射机制，代理类，字节码技术等等。它们都是在Spring实现中，涉及到的一些Java计算环境的底层技术；尽管对应用开发人员来说，可能不会直接去涉及这些JVM虚拟机底层实现的工作，但是了解这些背景知识，或多或少，对我们了解整个Spring平台的应用背景有很大的帮助；打个比方来说，就像我们在大学中，学习的那些关于计算机组织和系统方面的基本知识，比如像数字电路，计算机组成原理，汇编语言，操作系统等等这些基本课程的学习。虽然，坦率的来说，对我们这些大多数课程的学习者，在以后的工作中，可能并没有太多的机会，直接从事这么如此底层的技术开发工作；但具备这些知识背景，为我们深入理解基于这些基础技术构架起来的应用系统，毫无疑问，是不可缺少的。随着JVM虚拟机技术的发展，可以设想到的是，更多虚拟机级别的基本特性，将会持续的被应用平台开发者所关注和采用，这也是我们在学习平台实现的过程中，非常值得注意的一点，因为这些底层技术实现，毫无疑问，会对Spring应用平台的开发路线，产品策略产生重大的影响。同时，在使用Spring作为应用平台的时候，如果需要更深层次的开发和性能调优，这些底层的知识，也是我们知识库中不可缺少的部分。有了这些底层知识，理解整个系统，想来就应该障碍不大了。 

IOC的一点认识 
对Spring IOC的理解离不开对依赖反转模式的理解，我们知道，关于如何反转对依赖的控制，把控制权从具体业务对象手中转交到平台或者框架中，是解决面向对象系统设计复杂性和提高面向对象系统可测试性的一个有效的解决方案。这个问题触发了IoC设计模式的发展，是IoC容器要解决的核心问题。同时，也是产品化的IoC容器出现的推动力。而我觉得Spring的IoC容器，就是一个开源的实现依赖反转模式的产品。 

那具体什么是IoC容器呢？它在Spring框架中到底长什么样？说了这么多，其实对IoC容器的使用者来说，我们常常接触到的BeanFactory和ApplicationContext都可以看成是容器的具体表现形式。这些就是IoC容器，或者说在Spring中提IoC容器，从实现来说，指的是一个容器系列。这也就是说，我们通常所说的IoC容器，如果深入到Spring的实现去看，会发现IoC容器实际上代表着一系列功能各异的容器产品。只是容器的功能有大有小，有各自的特点。打个比方来说，就像是百货商店里出售的商品，我们举水桶为例子，在商店中出售的水桶有大有小；制作材料也各不相同，有金属的，有塑料的等等，总之是各式各样，但只要能装水，具备水桶的基本特性，那就可以作为水桶来出售来让用户使用。这在Spring中也是一样，它有各式各样的IoC容器的实现供用户选择和使用；使用什么样的容器完全取决于用户的需要，但在使用之前如果能够了解容器的基本情况，那会对容器的使用是非常有帮助的；就像我们在购买商品时进行的对商品的考察和挑选那样。 

我们从最基本的XmlBeanFactory看起，它是容器系列的最底层实现，这个容器的实现与我们在Spring应用中用到的那些上下文相比，有一个非常明显的特点，它只提供了最基本的IoC容器的功能。从它的名字中可以看出，这个IoC容器可以读取以XML形式定义的BeanDefinition。理解这一点有助于我们理解ApplicationContext与基本的BeanFactory之间的区别和联系。我们可以认为直接的BeanFactory实现是IoC容器的基本形式，而各种ApplicationContext的实现是IoC容器的高级表现形式。 

仔细阅读XmlBeanFactory的源码，在一开始的注释里面已经对 XmlBeanFactory的功能做了简要的说明，从代码的注释还可以看到，这是Rod Johnson在2001年就写下的代码，可见这个类应该是Spring的元老类了。它是继承DefaultListableBeanFactory这个类的，这个DefaultListableBeanFactory就是一个很值得注意的容器！ 

Java代码  复制代码  收藏代码
  1. public class XmlBeanFactory extends DefaultListableBeanFactory {  
  2.     private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);  
  3.     public XmlBeanFactory(Resource resource) throws BeansException {  
  4.         this(resource, null);  
  5.     }  
  6.     public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {  
  7.         super(parentBeanFactory);  
  8.         this.reader.loadBeanDefinitions(resource);  
  9.     }  
  10. }  
[java]  view plain  copy
  1. public class XmlBeanFactory extends DefaultListableBeanFactory {  
  2.     private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);  
  3.     public XmlBeanFactory(Resource resource) throws BeansException {  
  4.         this(resource, null);  
  5.     }  
  6.     public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {  
  7.         super(parentBeanFactory);  
  8.         this.reader.loadBeanDefinitions(resource);  
  9.     }  
  10. }  



XmlBeanFactory的功能是建立在DefaultListableBeanFactory这个基本容器的基础上的，在这个基本容器的基础上实现了其他诸如XML读取的附加功能。对于这些功能的实现原理，看一看XmlBeanFactory的代码实现就能很容易地理解。在如下的代码中可以看到，在XmlBeanFactory构造方法中需要得到Resource对象。对XmlBeanDefinitionReader对象的初始化，以及使用这个这个对象来完成loadBeanDefinitions的调用，就是这个调用启动了从Resource中载入BeanDefinitions的过程，这个loadBeanDefinitions同时也是IoC容器初始化的重要组成部分。 

简单来说，IoC容器的初始化包括BeanDefinition的Resouce定位、载入和注册这三个基本的过程。我觉得重点是在载入和对BeanDefinition做解析的这个过程。可以从DefaultListableBeanFactory来入手看看IoC容器是怎样完成BeanDefinition载入的。在refresh调用完成以后，可以看到loadDefinition的调用： 

Java代码  复制代码  收藏代码
  1. public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {  
  2.     public AbstractXmlApplicationContext() {  
  3.     }  
  4.     public AbstractXmlApplicationContext(ApplicationContext parent) {  
  5.         super(parent);  
  6.     }  
  7.     //这里是实现loadBeanDefinitions的地方  
  8.     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {  
  9.         // Create a new XmlBeanDefinitionReader for the given BeanFactory.  
  10.         // 创建 XmlBeanDefinitionReader，并通过回调设置到 BeanFactory中去，创建BeanFactory的使用的也是 DefaultListableBeanFactory。  
  11.         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
  12.   
  13.         // Configure the bean definition reader with this context's  
  14.         // resource loading environment.  
  15.         // 这里设置 XmlBeanDefinitionReader， 为XmlBeanDefinitionReader 配置ResourceLoader，因为DefaultResourceLoader是父类，所以this可以直接被使用  
  16.         beanDefinitionReader.setResourceLoader(this);  
  17.         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
  18.   
  19.         // Allow a subclass to provide custom initialization of the reader,  
  20.         // then proceed with actually loading the bean definitions.  
  21.     // 这是启动Bean定义信息载入的过程  
  22.         initBeanDefinitionReader(beanDefinitionReader);  
  23.         loadBeanDefinitions(beanDefinitionReader);  
  24.     }  
  25.   
  26.     protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {  
  27.     }  
[java]  view plain  copy
  1. public abstract class AbstractXmlApplicationContext extends AbstractRefreshableConfigApplicationContext {  
  2.     public AbstractXmlApplicationContext() {  
  3.     }  
  4.     public AbstractXmlApplicationContext(ApplicationContext parent) {  
  5.         super(parent);  
  6.     }  
  7.     //这里是实现loadBeanDefinitions的地方  
  8.     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {  
  9.         // Create a new XmlBeanDefinitionReader for the given BeanFactory.  
  10.         // 创建 XmlBeanDefinitionReader，并通过回调设置到 BeanFactory中去，创建BeanFactory的使用的也是 DefaultListableBeanFactory。  
  11.         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);  
  12.   
  13.         // Configure the bean definition reader with this context's  
  14.         // resource loading environment.  
  15.         // 这里设置 XmlBeanDefinitionReader， 为XmlBeanDefinitionReader 配置ResourceLoader，因为DefaultResourceLoader是父类，所以this可以直接被使用  
  16.         beanDefinitionReader.setResourceLoader(this);  
  17.         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));  
  18.   
  19.         // Allow a subclass to provide custom initialization of the reader,  
  20.         // then proceed with actually loading the bean definitions.  
  21.     // 这是启动Bean定义信息载入的过程  
  22.         initBeanDefinitionReader(beanDefinitionReader);  
  23.         loadBeanDefinitions(beanDefinitionReader);  
  24.     }  
  25.   
  26.     protected void initBeanDefinitionReader(XmlBeanDefinitionReader beanDefinitionReader) {  
  27.     }  

这里使用 XmlBeanDefinitionReader来载入BeanDefinition到容器中，如以下代码清单所示： 

Java代码  复制代码  收藏代码
  1.     //这里是调用的入口。  
  2.     public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {  
  3.         return loadBeanDefinitions(new EncodedResource(resource));  
  4.     }  
  5.     //这里是载入XML形式的BeanDefinition的地方。  
  6.     public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
  7.         Assert.notNull(encodedResource, "EncodedResource must not be null");  
  8.         if (logger.isInfoEnabled()) {  
  9.             logger.info("Loading XML bean definitions from " + encodedResource.getResource());  
  10.         }  
  11.   
  12.         Set currentResources = this.resourcesCurrentlyBeingLoaded.get();  
  13.         if (currentResources == null) {  
  14.             currentResources = new HashSet(4);  
  15.             this.resourcesCurrentlyBeingLoaded.set(currentResources);  
  16.         }  
  17.         if (!currentResources.add(encodedResource)) {  
  18.             throw new BeanDefinitionStoreException(  
  19.                     "Detected recursive loading of " + encodedResource + " - check your import definitions!");  
  20.         }  
  21.         //这里得到XML文件，并得到IO的InputSource准备进行读取。  
  22.         try {  
  23.             InputStream inputStream = encodedResource.getResource().getInputStream();  
  24.             try {  
  25.                 InputSource inputSource = new InputSource(inputStream);  
  26.                 if (encodedResource.getEncoding() != null) {  
  27.                     inputSource.setEncoding(encodedResource.getEncoding());  
  28.                 }  
  29.                 return doLoadBeanDefinitions(inputSource, encodedResource.getResource());  
  30.             }  
  31.             finally {  
  32.                 inputStream.close();  
  33.             }  
  34.         }  
  35.         catch (IOException ex) {  
  36.             throw new BeanDefinitionStoreException(  
  37.                     "IOException parsing XML document from " + encodedResource.getResource(), ex);  
  38.         }  
  39.         finally {  
  40.             currentResources.remove(encodedResource);  
  41.             if (currentResources.isEmpty()) {  
  42.                 this.resourcesCurrentlyBeingLoaded.set(null);  
  43.             }  
  44.         }  
  45.     }  
  46. //具体的读取过程可以在doLoadBeanDefinitions方法中找到：  
  47.     //这是从特定的XML文件中实际载入BeanDefinition的地方  
  48.     protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)  
  49.             throws BeanDefinitionStoreException {  
  50.         try {  
  51.             int validationMode = getValidationModeForResource(resource);  
  52.             //这里取得XML文件的Document对象，这个解析过程是由 documentLoader完成的，这个documentLoader是DefaultDocumentLoader,在定义documentLoader的地方创建  
  53.             Document doc = this.documentLoader.loadDocument(  
  54.                     inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());  
  55.             //这里启动的是对BeanDefinition解析的详细过程，这个解析会使用到Spring的Bean配置规则，是我们下面需要详细关注的地方。  
  56.             return registerBeanDefinitions(doc, resource);  
  57.         }  
  58.         catch (BeanDefinitionStoreException ex) {  
  59.             throw ex;  
  60.         }  
  61.         catch (SAXParseException ex) {  
  62.             throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
  63.                     "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);  
  64.         }  
  65.         catch (SAXException ex) {  
  66.             throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
  67.                     "XML document from " + resource + " is invalid", ex);  
  68.         }  
  69.         catch (ParserConfigurationException ex) {  
  70.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  71.                     "Parser configuration exception parsing XML from " + resource, ex);  
  72.         }  
  73.         catch (IOException ex) {  
  74.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  75.                     "IOException parsing XML document from " + resource, ex);  
  76.         }  
  77.         catch (Throwable ex) {  
  78.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  79.                     "Unexpected exception parsing XML document from " + resource, ex);  
  80.         }  
  81.     }  
[java]  view plain  copy
  1.     //这里是调用的入口。  
  2.     public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {  
  3.         return loadBeanDefinitions(new EncodedResource(resource));  
  4.     }  
  5.     //这里是载入XML形式的BeanDefinition的地方。  
  6.     public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {  
  7.         Assert.notNull(encodedResource, "EncodedResource must not be null");  
  8.         if (logger.isInfoEnabled()) {  
  9.             logger.info("Loading XML bean definitions from " + encodedResource.getResource());  
  10.         }  
  11.   
  12.         Set currentResources = this.resourcesCurrentlyBeingLoaded.get();  
  13.         if (currentResources == null) {  
  14.             currentResources = new HashSet(4);  
  15.             this.resourcesCurrentlyBeingLoaded.set(currentResources);  
  16.         }  
  17.         if (!currentResources.add(encodedResource)) {  
  18.             throw new BeanDefinitionStoreException(  
  19.                     "Detected recursive loading of " + encodedResource + " - check your import definitions!");  
  20.         }  
  21.         //这里得到XML文件，并得到IO的InputSource准备进行读取。  
  22.         try {  
  23.             InputStream inputStream = encodedResource.getResource().getInputStream();  
  24.             try {  
  25.                 InputSource inputSource = new InputSource(inputStream);  
  26.                 if (encodedResource.getEncoding() != null) {  
  27.                     inputSource.setEncoding(encodedResource.getEncoding());  
  28.                 }  
  29.                 return doLoadBeanDefinitions(inputSource, encodedResource.getResource());  
  30.             }  
  31.             finally {  
  32.                 inputStream.close();  
  33.             }  
  34.         }  
  35.         catch (IOException ex) {  
  36.             throw new BeanDefinitionStoreException(  
  37.                     "IOException parsing XML document from " + encodedResource.getResource(), ex);  
  38.         }  
  39.         finally {  
  40.             currentResources.remove(encodedResource);  
  41.             if (currentResources.isEmpty()) {  
  42.                 this.resourcesCurrentlyBeingLoaded.set(null);  
  43.             }  
  44.         }  
  45.     }  
  46. //具体的读取过程可以在doLoadBeanDefinitions方法中找到：  
  47.     //这是从特定的XML文件中实际载入BeanDefinition的地方  
  48.     protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)  
  49.             throws BeanDefinitionStoreException {  
  50.         try {  
  51.             int validationMode = getValidationModeForResource(resource);  
  52.             //这里取得XML文件的Document对象，这个解析过程是由 documentLoader完成的，这个documentLoader是DefaultDocumentLoader,在定义documentLoader的地方创建  
  53.             Document doc = this.documentLoader.loadDocument(  
  54.                     inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());  
  55.             //这里启动的是对BeanDefinition解析的详细过程，这个解析会使用到Spring的Bean配置规则，是我们下面需要详细关注的地方。  
  56.             return registerBeanDefinitions(doc, resource);  
  57.         }  
  58.         catch (BeanDefinitionStoreException ex) {  
  59.             throw ex;  
  60.         }  
  61.         catch (SAXParseException ex) {  
  62.             throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
  63.                     "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);  
  64.         }  
  65.         catch (SAXException ex) {  
  66.             throw new XmlBeanDefinitionStoreException(resource.getDescription(),  
  67.                     "XML document from " + resource + " is invalid", ex);  
  68.         }  
  69.         catch (ParserConfigurationException ex) {  
  70.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  71.                     "Parser configuration exception parsing XML from " + resource, ex);  
  72.         }  
  73.         catch (IOException ex) {  
  74.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  75.                     "IOException parsing XML document from " + resource, ex);  
  76.         }  
  77.         catch (Throwable ex) {  
  78.             throw new BeanDefinitionStoreException(resource.getDescription(),  
  79.                     "Unexpected exception parsing XML document from " + resource, ex);  
  80.         }  
  81.     }  

关于具体的Spring BeanDefinition的解析，是在BeanDefinitionParserDelegate中完成的。这个类里包含了各种Spring Bean定义规则的处理，感兴趣的同学可以仔细研究。我们举一个例子来分析这个处理过程，比如我们最熟悉的对Bean元素的处理是怎样完成的，也就是我们在XML定义文件中出现的这个最常见的元素信息是怎样被处理的。在这里，我们会看到那些熟悉的BeanDefinition定义的处理，比如id、name、aliase等属性元素。把这些元素的值从XML文件相应的元素的属性中读取出来以后，会被设置到生成的BeanDefinitionHolder中去。这些属性的解析还是比较简单的。对于其他元素配置的解析，比如各种Bean的属性配置，通过一个较为复杂的解析过程，这个过程是由parseBeanDefinitionElement来完成的。解析完成以后，会把解析结果放到BeanDefinition对象中并设置到BeanDefinitionHolder中去，如以下清单所示： 

Java代码  复制代码  收藏代码
  1. public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
  2.         //这里取得在元素中定义的id、name和aliase属性的值  
  3.         String id = ele.getAttribute(ID_ATTRIBUTE);  
  4.         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
  5.   
  6.         List aliases = new ArrayList();  
  7.         if (StringUtils.hasLength(nameAttr)) {  
  8.             String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);  
  9.             aliases.addAll(Arrays.asList(nameArr));  
  10.         }  
  11.   
  12.         String beanName = id;  
  13.         if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {  
  14.             beanName = aliases.remove(0);  
  15.             if (logger.isDebugEnabled()) {  
  16.                 logger.debug("No XML 'id' specified - using '" + beanName +  
  17.                         "' as bean name and " + aliases + " as aliases");  
  18.             }  
  19.         }  
  20.   
  21.         if (containingBean == null) {  
  22.             checkNameUniqueness(beanName, aliases, ele);  
  23.         }  
  24.   
  25.         //这个方法会引发对bean元素的详细解析  
  26. AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
  27.         if (beanDefinition != null) {  
  28.             if (!StringUtils.hasText(beanName)) {  
  29.                 try {  
  30.                     if (containingBean != null) {  
  31.                         beanName = BeanDefinitionReaderUtils.generateBeanName(  
  32.                                 beanDefinition, this.readerContext.getRegistry(), true);  
  33.                     }  
  34.                     else {  
  35.                         beanName = this.readerContext.generateBeanName(beanDefinition);  
  36.                         // Register an alias for the plain bean class name, if still possible,  
  37.                         // if the generator returned the class name plus a suffix.  
  38.                         // This is expected for Spring 1.2/2.0 backwards compatibility.  
  39.                         String beanClassName = beanDefinition.getBeanClassName();  
  40.                         if (beanClassName != null &&  
  41.                                 beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&  
  42.                                 !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {  
  43.                             aliases.add(beanClassName);  
  44.                         }  
  45.                     }  
  46.                     if (logger.isDebugEnabled()) {  
  47.                         logger.debug("Neither XML 'id' nor 'name' specified - " +  
  48.                                 "using generated bean name [" + beanName + "]");  
  49.                     }  
  50.                 }  
  51.                 catch (Exception ex) {  
  52.                     error(ex.getMessage(), ele);  
  53.                     return null;  
  54.                 }  
  55.             }  
  56.             String[] aliasesArray = StringUtils.toStringArray(aliases);  
  57.             return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);  
  58.         }  
  59.   
  60.         return null;  
  61.     }  
[java]  view plain  copy
  1. public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {  
  2.         //这里取得在元素中定义的id、name和aliase属性的值  
  3.         String id = ele.getAttribute(ID_ATTRIBUTE);  
  4.         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  
  5.   
  6.         List aliases = new ArrayList();  
  7.         if (StringUtils.hasLength(nameAttr)) {  
  8.             String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, BEAN_NAME_DELIMITERS);  
  9.             aliases.addAll(Arrays.asList(nameArr));  
  10.         }  
  11.   
  12.         String beanName = id;  
  13.         if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {  
  14.             beanName = aliases.remove(0);  
  15.             if (logger.isDebugEnabled()) {  
  16.                 logger.debug("No XML 'id' specified - using '" + beanName +  
  17.                         "' as bean name and " + aliases + " as aliases");  
  18.             }  
  19.         }  
  20.   
  21.         if (containingBean == null) {  
  22.             checkNameUniqueness(beanName, aliases, ele);  
  23.         }  
  24.   
  25.         //这个方法会引发对bean元素的详细解析  
  26. AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);  
  27.         if (beanDefinition != null) {  
  28.             if (!StringUtils.hasText(beanName)) {  
  29.                 try {  
  30.                     if (containingBean != null) {  
  31.                         beanName = BeanDefinitionReaderUtils.generateBeanName(  
  32.                                 beanDefinition, this.readerContext.getRegistry(), true);  
  33.                     }  
  34.                     else {  
  35.                         beanName = this.readerContext.generateBeanName(beanDefinition);  
  36.                         // Register an alias for the plain bean class name, if still possible,  
  37.                         // if the generator returned the class name plus a suffix.  
  38.                         // This is expected for Spring 1.2/2.0 backwards compatibility.  
  39.                         String beanClassName = beanDefinition.getBeanClassName();  
  40.                         if (beanClassName != null &&  
  41.                                 beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&  
  42.                                 !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {  
  43.                             aliases.add(beanClassName);  
  44.                         }  
  45.                     }  
  46.                     if (logger.isDebugEnabled()) {  
  47.                         logger.debug("Neither XML 'id' nor 'name' specified - " +  
  48.                                 "using generated bean name [" + beanName + "]");  
  49.                     }  
  50.                 }  
  51.                 catch (Exception ex) {  
  52.                     error(ex.getMessage(), ele);  
  53.                     return null;  
  54.                 }  
  55.             }  
  56.             String[] aliasesArray = StringUtils.toStringArray(aliases);  
  57.             return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);  
  58.         }  
  59.   
  60.         return null;  
  61.     }  

在具体生成BeanDefinition以后。我们举一个对property进行解析的例子来完成对整个BeanDefinition载入过程的分析，还是在类BeanDefinitionParserDelegate的代码中，它对BeanDefinition中的定义一层一层地进行解析，比如从属性元素集合到具体的每一个属性元素，然后才是对具体的属性值的处理。根据解析结果，对这些属性值的处理会封装成PropertyValue对象并设置到BeanDefinition对象中去，如以下代码清单所示。 
Java代码  复制代码  收藏代码
  1. /** 
  2.  * 这里对指定bean元素的property子元素集合进行解析。 
  3.  */  
  4. public void parsePropertyElements(Element beanEle, BeanDefinition bd) {  
  5.     //遍历所有bean元素下定义的property元素  
  6.     NodeList nl = beanEle.getChildNodes();  
  7.     for (int i = 0; i < nl.getLength(); i++) {  
  8.         Node node = nl.item(i);  
  9.         if (node instanceof Element && DomUtils.nodeNameEquals(node, PROPERTY_ELEMENT)) {  
  10.             //在判断是property元素后对该property元素进行解析的过程  
  11.             parsePropertyElement((Element) node, bd);  
  12.         }  
  13.     }  
  14. }  
  15. public void parsePropertyElement(Element ele, BeanDefinition bd) {  
  16.     //这里取得property的名字  
  17.     String propertyName = ele.getAttribute(NAME_ATTRIBUTE);  
  18.     if (!StringUtils.hasLength(propertyName)) {  
  19.         error("Tag 'property' must have a 'name' attribute", ele);  
  20.         return;  
  21.     }  
  22.     this.parseState.push(new PropertyEntry(propertyName));  
  23.     try {  
  24.         //如果同一个bean中已经有同名的存在，则不进行解析，直接返回。也就是说，如果在同一个bean中有同名的property设置，那么起作用的只是第一个。  
  25.         if (bd.getPropertyValues().contains(propertyName)) {  
  26.             error("Multiple 'property' definitions for property '" + propertyName + "'", ele);  
  27.             return;  
  28.         }  
  29.         //这里是解析property值的地方，返回的对象对应对Bean定义的property属性设置的解析结果，这个解析结果会封装到PropertyValue对象中，然后设置到BeanDefinitionHolder中去。  
  30.         Object val = parsePropertyValue(ele, bd, propertyName);  
  31.         PropertyValue pv = new PropertyValue(propertyName, val);  
  32.         parseMetaElements(ele, pv);  
  33.         pv.setSource(extractSource(ele));  
  34.         bd.getPropertyValues().addPropertyValue(pv);  
  35.     }  
  36.     finally {  
  37.         this.parseState.pop();  
  38.     }  
  39. }  
  40. /** 
  41.  * 这里取得property元素的值，也许是一个list或其他。 
  42.  */  
  43. public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {  
  44.     String elementName = (propertyName != null) ?  
  45.                     " element for property '" + propertyName + "'" :  
  46.                     " element";  
  47.   
  48.     // Should only have one child element: ref, value, list, etc.  
  49.     NodeList nl = ele.getChildNodes();  
  50.     Element subElement = null;  
  51.     for (int i = 0; i < nl.getLength(); i++) {  
  52.         Node node = nl.item(i);  
  53.         if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT) &&  
  54.                 !DomUtils.nodeNameEquals(node, META_ELEMENT)) {  
  55.             // Child element is what we're looking for.  
  56.             if (subElement != null) {  
  57.                 error(elementName + " must not contain more than one sub-element", ele);  
  58.             }  
  59.             else {  
  60.                 subElement = (Element) node;  
  61.             }  
  62.         }  
  63.     }  
  64.     //这里判断property的属性，是ref还是value,不允许同时是ref和value。  
  65.     boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);  
  66.     boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);  
  67.     if ((hasRefAttribute && hasValueAttribute) ||  
  68.             ((hasRefAttribute || hasValueAttribute) && subElement != null)) {  
  69.         error(elementName +  
  70.                 " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);  
  71.     }  
  72.     //如果是ref，创建一个ref的数据对象RuntimeBeanReference,这个对象封装了ref的信息。  
  73.     if (hasRefAttribute) {  
  74.         String refName = ele.getAttribute(REF_ATTRIBUTE);  
  75.         if (!StringUtils.hasText(refName)) {  
  76.             error(elementName + " contains empty 'ref' attribute", ele);  
  77.         }  
  78.         RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
  79.         ref.setSource(extractSource(ele));  
  80.         return ref;  
  81.     } //如果是value，创建一个value的数据对象TypedStringValue ,这个对象封装了value的信息。  
  82.     else if (hasValueAttribute) {  
  83.         TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));  
  84.         valueHolder.setSource(extractSource(ele));  
  85.         return valueHolder;  
  86.     } //如果还有子元素，触发对子元素的解析  
  87.     else if (subElement != null) {  
  88.         return parsePropertySubElement(subElement, bd);  
  89.     }  
  90.     else {  
  91.         // Neither child element nor "ref" or "value" attribute found.  
  92.         error(elementName + " must specify a ref or value", ele);  
  93.         return null;  
  94.     }  
  95. }  
[java]  view plain  copy
  1. /** 
  2.  * 这里对指定bean元素的property子元素集合进行解析。 
  3.  */  
  4. public void parsePropertyElements(Element beanEle, BeanDefinition bd) {  
  5.     //遍历所有bean元素下定义的property元素  
  6.     NodeList nl = beanEle.getChildNodes();  
  7.     for (int i = 0; i < nl.getLength(); i++) {  
  8.         Node node = nl.item(i);  
  9.         if (node instanceof Element && DomUtils.nodeNameEquals(node, PROPERTY_ELEMENT)) {  
  10.             //在判断是property元素后对该property元素进行解析的过程  
  11.             parsePropertyElement((Element) node, bd);  
  12.         }  
  13.     }  
  14. }  
  15. public void parsePropertyElement(Element ele, BeanDefinition bd) {  
  16.     //这里取得property的名字  
  17.     String propertyName = ele.getAttribute(NAME_ATTRIBUTE);  
  18.     if (!StringUtils.hasLength(propertyName)) {  
  19.         error("Tag 'property' must have a 'name' attribute", ele);  
  20.         return;  
  21.     }  
  22.     this.parseState.push(new PropertyEntry(propertyName));  
  23.     try {  
  24.         //如果同一个bean中已经有同名的存在，则不进行解析，直接返回。也就是说，如果在同一个bean中有同名的property设置，那么起作用的只是第一个。  
  25.         if (bd.getPropertyValues().contains(propertyName)) {  
  26.             error("Multiple 'property' definitions for property '" + propertyName + "'", ele);  
  27.             return;  
  28.         }  
  29.         //这里是解析property值的地方，返回的对象对应对Bean定义的property属性设置的解析结果，这个解析结果会封装到PropertyValue对象中，然后设置到BeanDefinitionHolder中去。  
  30.         Object val = parsePropertyValue(ele, bd, propertyName);  
  31.         PropertyValue pv = new PropertyValue(propertyName, val);  
  32.         parseMetaElements(ele, pv);  
  33.         pv.setSource(extractSource(ele));  
  34.         bd.getPropertyValues().addPropertyValue(pv);  
  35.     }  
  36.     finally {  
  37.         this.parseState.pop();  
  38.     }  
  39. }  
  40. /** 
  41.  * 这里取得property元素的值，也许是一个list或其他。 
  42.  */  
  43. public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {  
  44.     String elementName = (propertyName != null) ?  
  45.                     " element for property '" + propertyName + "'" :  
  46.                     " element";  
  47.   
  48.     // Should only have one child element: ref, value, list, etc.  
  49.     NodeList nl = ele.getChildNodes();  
  50.     Element subElement = null;  
  51.     for (int i = 0; i < nl.getLength(); i++) {  
  52.         Node node = nl.item(i);  
  53.         if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT) &&  
  54.                 !DomUtils.nodeNameEquals(node, META_ELEMENT)) {  
  55.             // Child element is what we're looking for.  
  56.             if (subElement != null) {  
  57.                 error(elementName + " must not contain more than one sub-element", ele);  
  58.             }  
  59.             else {  
  60.                 subElement = (Element) node;  
  61.             }  
  62.         }  
  63.     }  
  64.     //这里判断property的属性，是ref还是value,不允许同时是ref和value。  
  65.     boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);  
  66.     boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);  
  67.     if ((hasRefAttribute && hasValueAttribute) ||  
  68.             ((hasRefAttribute || hasValueAttribute) && subElement != null)) {  
  69.         error(elementName +  
  70.                 " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);  
  71.     }  
  72.     //如果是ref，创建一个ref的数据对象RuntimeBeanReference,这个对象封装了ref的信息。  
  73.     if (hasRefAttribute) {  
  74.         String refName = ele.getAttribute(REF_ATTRIBUTE);  
  75.         if (!StringUtils.hasText(refName)) {  
  76.             error(elementName + " contains empty 'ref' attribute", ele);  
  77.         }  
  78.         RuntimeBeanReference ref = new RuntimeBeanReference(refName);  
  79.         ref.setSource(extractSource(ele));  
  80.         return ref;  
  81.     } //如果是value，创建一个value的数据对象TypedStringValue ,这个对象封装了value的信息。  
  82.     else if (hasValueAttribute) {  
  83.         TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));  
  84.         valueHolder.setSource(extractSource(ele));  
  85.         return valueHolder;  
  86.     } //如果还有子元素，触发对子元素的解析  
  87.     else if (subElement != null) {  
  88.         return parsePropertySubElement(subElement, bd);  
  89.     }  
  90.     else {  
  91.         // Neither child element nor "ref" or "value" attribute found.  
  92.         error(elementName + " must specify a ref or value", ele);  
  93.         return null;  
  94.     }  
  95. }  

比如，再往下看，我们看到像List这样的属性配置是怎样被解析的，依然在BeanDefinitionParserDelegate中：返回的是一个List对象，这个List是Spring定义的ManagedList，作为封装List这类配置定义的数据封装，如以下代码清单所示。 
Java代码  复制代码  收藏代码
  1. public List parseListElement(Element collectionEle, BeanDefinition bd) {  
  2.     String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
  3.     NodeList nl = collectionEle.getChildNodes();  
  4.     ManagedList target = new ManagedList(nl.getLength());  
  5.     target.setSource(extractSource(collectionEle));  
  6.     target.setElementTypeName(defaultElementType);  
  7.     target.setMergeEnabled(parseMergeAttribute(collectionEle));  
  8.     //具体的List元素的解析过程。  
  9.     parseCollectionElements(nl, target, bd, defaultElementType);  
  10.     return target;  
  11. }  
  12. protected void parseCollectionElements(  
  13.         NodeList elementNodes, Collection target, BeanDefinition bd, String defaultElementType) {  
  14.     //遍历所有的元素节点，并判断其类型是否为Element。  
  15.     for (int i = 0; i < elementNodes.getLength(); i++) {  
  16.         Node node = elementNodes.item(i);  
  17.         if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT)) {  
  18.     //加入到target中去，target是一个ManagedList，同时触发对下一层子元素的解析过程，这是一个递归的调用。  
  19.             target.add(parsePropertySubElement((Element) node, bd, defaultElementType));  
  20.         }  
  21.     }  
  22. }  
    23. [java]  view plain  copy
    1. public List parseListElement(Element collectionEle, BeanDefinition bd) {  
    2.     String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE);  
    3.     NodeList nl = collectionEle.getChildNodes();  
    4.     ManagedList target = new ManagedList(nl.getLength());  
    5.     target.setSource(extractSource(collectionEle));  
    6.     target.setElementTypeName(defaultElementType);  
    7.     target.setMergeEnabled(parseMergeAttribute(collectionEle));  
    8.     //具体的List元素的解析过程。  
    9.     parseCollectionElements(nl, target, bd, defaultElementType);  
    10.     return target;  
    11. }  
    12. protected void parseCollectionElements(  
    13.         NodeList elementNodes, Collection target, BeanDefinition bd, String defaultElementType) {  
    14.     //遍历所有的元素节点，并判断其类型是否为Element。  
    15.     for (int i = 0; i < elementNodes.getLength(); i++) {  
    16.         Node node = elementNodes.item(i);  
    17.         if (node instanceof Element && !DomUtils.nodeNameEquals(node, DESCRIPTION_ELEMENT)) {  
    18.     //加入到target中去，target是一个ManagedList，同时触发对下一层子元素的解析过程，这是一个递归的调用。  
    19.             target.add(parsePropertySubElement((Element) node, bd, defaultElementType));  
    20.         }  
    21.     }  
    22. }  

      23. 经过这样一层一层的解析，我们在XML文件中定义的BeanDefinition就被整个给载入到了IoC容器中，并在容器中建立了数据映射。在IoC容器中建立了对应的数据结构，或者说可以看成是POJO对象在IoC容器中的映像，这些数据结构可以以AbstractBeanDefinition为入口，让IoC容器执行索引、查询和操作。 

      在我的感觉中，对核心数据结构的定义和处理应该可以看成是一个软件的核心部分了。所以，这里的BeanDefinition的载入可以说是IoC容器的核心，如果说IoC容器是Spring的核心，那么这些BeanDefinition就是Spring的核心的核心了！ 

      呵呵，这部分代码数量不小，但如果掌握这条主线，其他都可以举一反三吧，就像我们掌握了操作系统启动的过程，以及在操作系统设计中的核心数据结构像进程数据结构，文件系统数据结构，网络协议数据结构的设计和处理一样，对整个系统的设计原理，包括移植，驱动开发和应用开发，是非常有帮助的！ 

      你可能感兴趣的:(spring,spring)

      • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
        SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
      • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
        目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
      • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
        前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
      • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
        这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
      • Spring MVC 全面指南：从入门到精通的详细解析 一杯梅子酱 技术栈学习springmvcjava
        引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
      • Spring Boot中实现跨域请求 BABA8891 springboot后端java
        在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
      • 博客网站制作教程 2401_85194651 javamaven
        首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
      • RabbitMQ生产者重复机制与确认机制 java炒饭小能手 java-rabbitmqrabbitmqjava
        重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
      • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException 屿小夏 java开发语言
        文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
      • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗? 瑞金彭于晏 springboot后端javaMVCspring数据库
        SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
      • spring mvc @RequestBody String类型参数 zoyation spring-mvcspringmvc
        通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
      • Java -jar 如何在后台运行项目 vincent_hahaha
        撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
      • spring security中几大组件的作用和执行顺序 阿信在这里 javaspring
        springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
      • 探索Zebra4J：构建高效企业级Web应用的微服务框架 叶准鑫Natalie
        探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
      • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台 网顺技术团队 成品程序项目javavue.js汽车课程设计springboot
        基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
      • 分布式锁和spring事务管理 暴躁的鱼 锁及事务分布式springjava
        最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
      • Java面试笔记记录6 今天背八股了吗 java面试笔记
        1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
      • Sentinel 眼泪落在琴弦 springcloudjavajava
        Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
      • Spring @Async 深度解读：默认线程池执行器的配置与优化 小码快撩 springjava前端
        在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
      • Sentinel实时监控不展示问题 朱杰jjj sentinelsentinel
        问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
      • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
        在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
      • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
        博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
      • Spring Security静态资源过滤（11） 小黑屋说YYDS spring
        在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
      • Spring Security定义多个过滤器链（10） 小黑屋说YYDS spring
        在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
      • java 技术 架构 相关文档 圣心 java架构开发语言
        在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
      • SpringSecurity初学总结 weixin_66442229 spring
        springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
      • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式 花儿街参考
        ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
      • SpringBoot 设置传入参数非必要 loveLifeLoveCoding springbootspringbootjavaspring
        查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
      • SpringBoot 获取 ApplicationContext loveLifeLoveCoding springbootspringbootjavaspring
        1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
      • java打印标签（机型TOSHIBA条码打印机B-EX4T）  嘘  JAVAjava
        java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
      • ASM系列六 利用TreeApi 添加和移除类成员 lijingyao8206 jvm动态代理ASM字节码技术TreeAPI
            同生成的做法一样，添加和移除类成员只要去修改fields和methods中的元素即可。这里我们拿一个简单的类做例子，下面这个Task类，我们来移除isNeedRemove方法，并且添加一个int 类型的addedField属性。   package asm.core; /** * Created by yunshen.ljy on 2015/6/
      • Springmvc-权限设计 bee1314 springWebjsp
        万丈高楼平地起。 权限管理对于管理系统而言已经是标配中的标配了吧，对于我等俗人更是不能免俗。同时就目前的项目状况而言，我们还不需要那么高大上的开源的解决方案，如Spring Security，Shiro。小伙伴一致决定我们还是从基本的功能迭代起来吧。 目标： 1.实现权限的管理（CRUD） 2.实现部门管理 （CRUD) 3.实现人员的管理 （CRUD） 4.实现部门和权限
      • 算法竞赛入门经典（第二版）第2章习题 CrazyMizzz c算法
        2.4.1 输出技巧 #include <stdio.h> int main() { int i, n; scanf("%d", &n); for (i = 1; i <= n; i++) printf("%d\n", i); return 0; } 习题2-2 水仙花数(daffodil
      • struts2中jsp自动跳转到Action 麦田的设计者 jspwebxmlstruts2自动跳转
        1、在struts2的开发中，经常需要用户点击网页后就直接跳转到一个Action，执行Action里面的方法，利用mvc分层思想执行相应操作在界面上得到动态数据。毕竟用户不可能在地址栏里输入一个Action（不是专业人士）   2、＜jsp:forward page="xxx.action" /＞ ，这个标签可以实现跳转，page的路径是相对地址,不同与jsp和j
      • php 操作webservice实例 IT独行者 PHPwebservice
        首先大家要简单了解了何谓webservice，接下来就做两个非常简单的例子，webservice还是逃不开server端与client端。我测试的环境为：apache2.2.11 php5.2.10做这个测试之前，要确认你的php配置文件中已经将soap扩展打开，即extension=php_soap.dll; OK 现在我们来体验webservice //server端 serve
      • Windows下使用Vagrant安装linux系统 _wy_ windowsvagrant
        准备工作： 下载安装 VirtualBox ：https://www.virtualbox.org/ 下载安装 Vagrant ：http://www.vagrantup.com/ 下载需要使用的 box ： 官方提供的范例：http://files.vagrantup.com/precise32.box 还可以在 http://www.vagrantbox.es/ 
      • 更改linux的文件拥有者及用户组(chown和chgrp) 无量 clinuxchgrpchown
        本文（转） http://blog.163.com/yanenshun@126/blog/static/128388169201203011157308/ http://ydlmlh.iteye.com/blog/1435157 一、基本使用： 使用chown命令可以修改文件或目录所属的用户：        命令
      • linux下抓包工具 矮蛋蛋 linux
        原文地址： http://blog.chinaunix.net/uid-23670869-id-2610683.html tcpdump -nn -vv -X udp port 8888 上面命令是抓取udp包、端口为8888 netstat -tln 命令是用来查看linux的端口使用情况 13 . 列出所有的网络连接 lsof -i 14. 列出所有tcp 网络连接信息 l
      • 我觉得mybatis是垃圾！：“每一个用mybatis的男纸，你伤不起” alafqq mybatis
        最近看了  每一个用mybatis的男纸，你伤不起 原文地址 ：http://www.iteye.com/topic/1073938 发表一下个人看法。欢迎大神拍砖； 个人一直使用的是Ibatis框架，公司对其进行过小小的改良； 最近换了公司，要使用新的框架。听说mybatis不错；就对其进行了部分的研究； 发现多了一个mapper层；个人感觉就是个dao；
      • 解决java数据交换之谜 百合不是茶 数据交换
        交换两个数字的方法有以下三种 ，其中第一种最常用   /* 输出最小的一个数 */ public class jiaohuan1 { public static void main(String[] args) { int a =4; int b = 3; if(a<b){ // 第一种交换方式 int tmep =
      • 渐变显示 bijian1013 JavaScript
        <style type="text/css"> #wxf { FILTER: progid:DXImageTransform.Microsoft.Gradient(GradientType=0, StartColorStr=#ffffff, EndColorStr=#97FF98); height: 25px; } </style>
      • 探索JUnit4扩展：断言语法assertThat bijian1013 java单元测试assertThat
        一.概述         JUnit 设计的目的就是有效地抓住编程人员写代码的意图，然后快速检查他们的代码是否与他们的意图相匹配。 JUnit 发展至今，版本不停的翻新，但是所有版本都一致致力于解决一个问题，那就是如何发现编程人员的代码意图，并且如何使得编程人员更加容易地表达他们的代码意图。JUnit 4.4 也是为了如何能够
      • 【Gson三】Gson解析{"data":{"IM":["MSN","QQ","Gtalk"]}} bit1129 gson
          如何把如下简单的JSON字符串反序列化为Java的POJO对象? {"data":{"IM":["MSN","QQ","Gtalk"]}}   下面的POJO类Model无法完成正确的解析：   import com.google.gson.Gson;
      • 【Kafka九】Kafka High Level API vs. Low Level API bit1129 kafka
        1. Kafka提供了两种Consumer API High Level Consumer API Low Level Consumer API(Kafka诡异的称之为Simple Consumer API，实际上非常复杂) 在选用哪种Consumer API时，首先要弄清楚这两种API的工作原理，能做什么不能做什么，能做的话怎么做的以及用的时候，有哪些可能的问题  
      • 在nginx中集成lua脚本：添加自定义Http头，封IP等 ronin47 nginx lua
        Lua是一个可以嵌入到Nginx配置文件中的动态脚本语言，从而可以在Nginx请求处理的任何阶段执行各种Lua代码。刚开始我们只是用Lua 把请求路由到后端服务器，但是它对我们架构的作用超出了我们的预期。下面就讲讲我们所做的工作。 强制搜索引擎只索引mixlr.com Google把子域名当作完全独立的网站，我们不希望爬虫抓取子域名的页面，降低我们的Page rank。 location /{
      • java-归并排序 bylijinnan java
        import java.util.Arrays; public class MergeSort { public static void main(String[] args) { int[] a={20,1,3,8,5,9,4,25}; mergeSort(a,0,a.length-1); System.out.println(Arrays.to
      • Netty源码学习-CompositeChannelBuffer bylijinnan javanetty
        CompositeChannelBuffer体现了Netty的“Transparent Zero Copy” 查看API（ http://docs.jboss.org/netty/3.2/api/org/jboss/netty/buffer/package-summary.html#package_description） 可以看到，所谓“Transparent Zero Copy”是通
      • Android中给Activity添加返回键 hotsunshine Activity
        // this need android:minSdkVersion="11" getActionBar().setDisplayHomeAsUpEnabled(true); @Override public boolean onOptionsItemSelected(MenuItem item) {
      • 静态页面传参 ctrain 静态
        $(document).ready(function () { var request = { QueryString : function (val) { var uri = window.location.search; var re = new RegExp("" + val + "=([^&?]*)", &
      • Windows中查找某个目录下的所有文件中包含某个字符串的命令 daizj windows查找某个目录下的所有文件包含某个字符串
        findstr可以完成这个工作。   [html]  view plain copy   >findstr /s /i "string" *.*   上面的命令表示，当前目录以及当前目录的所有子目录下的所有文件中查找"string&qu
      • 改善程序代码质量的一些技巧 dcj3sjt126com 编程PHP重构
        有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。让我们看一些基本的编程技巧：    尽量保持方法简短    尽管很多人都遵
      • SharedPreferences对数据的存储 dcj3sjt126com
        SharedPreferences简介：                                                   &nbs
      • linux复习笔记之bash shell (2) bash基础 eksliang bashbash shell
        转载请出自出处： http://eksliang.iteye.com/blog/2104329 1.影响显示结果的语系变量（locale）  1.1locale这个命令就是查看当前系统支持多少种语系，命令使用如下： [root@localhost shell]# locale LANG=en_US.UTF-8 LC_CTYPE="en_US.UTF-8"
      • Android零碎知识总结 gqdy365 android
        1、CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。 所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高
      • HoverTree.Model.ArticleSelect类的作用 hvt Web.netC#hovertreeasp.net
        ArticleSelect类在命名空间HoverTree.Model中可以认为是文章查询条件类，用于存放查询文章时的条件，例如HvtId就是文章的id。HvtIsShow就是文章的显示属性，当为-1是，该条件不产生作用，当为0时，查询不公开显示的文章，当为1时查询公开显示的文章。HvtIsHome则为是否在首页显示。HoverTree系统源码完全开放，开发环境为Visual Studio 2013
      • PHP 判断是否使用代理 PHP Proxy Detector 天梯梦 proxy
        1. php 类 I found this class looking for something else actually but I remembered I needed some while ago something similar and I never found one. I'm sure it will help a lot of developers who try to
      • apache的math库中的回归——regression（翻译） lvdccyb Mathapache
        这个Math库，虽然不向weka那样专业的ML库，但是用户友好，易用。 多元线性回归，协方差和相关性（皮尔逊和斯皮尔曼），分布测试（假设检验，t，卡方，G），统计。   数学库中还包含，Cholesky，LU，SVD，QR，特征根分解，真不错。   基本覆盖了：线代，统计，矩阵， 最优化理论 曲线拟合 常微分方程 遗传算法（GA）， 还有3维的运算。。。
      • 基础数据结构和算法十三：Undirected Graphs (2) sunwinner Algorithm
          Design pattern for graph processing. Since we consider a large number of graph-processing algorithms, our initial design goal is to decouple our implementations from the graph representation
      • 云计算平台最重要的五项技术 sumapp 云计算云平台智城云
        云计算平台最重要的五项技术 1、云服务器 云服务器提供简单高效，处理能力可弹性伸缩的计算服务，支持国内领先的云计算技术和大规模分布存储技术，使您的系统更稳定、数据更安全、传输更快速、部署更灵活。 特性 机型丰富 通过高性能服务器虚拟化为云服务器，提供丰富配置类型虚拟机，极大简化数据存储、数据库搭建、web服务器搭建等工作； 仅需要几分钟，根据CP
      • 《京东技术解密》有奖试读获奖名单公布 ITeye管理员 活动
        ITeye携手博文视点举办的12月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。  12月试读活动回顾： http://webmaster.iteye.com/blog/2164754 本次技术图书试读活动获奖名单及相应作品如下： 一等奖（两名） Microhardest：http://microhardest.ite