一直不懂
一直不懂

【Spring源码分析】34-Spring Bean作用域的设计与实现

1、Spring Bean作用域简介

bean定义的配方是很重要的，因为这意味着，对于一个类，你可以使用一个配方创建许多对象实例。你不仅可以通过特定的bean定义控制各种依赖关系和配置值创建一个对象，还控制创建的对象的作用域。这种方法是强大和灵活的，因为你可以选择您创建的对象的作用域通过配置，而不是靠对象在Java类级别的作用域。可以定义bean被部署在一个作用域。Spring框架支持六个作用域，其中四个作用域需要使用带有Web功能的ApplicationContext(AbstractRefreshableWebApplicationContext)。您还可以创建一个自定义作用域。下表描述了支持的作用域：

Bean作用域
作用域 描述

singleton

(默认作用域) 一个bean定义对应一个在Spring IoC容器中存在的对象实例。

prototype

 一个bean定义可以创建任意数量的对象实例。

request

 一个bean定义代表一个单独的HTTP请求的生命周期。也就是说，每个HTTP请求都有自己的bean的实例。只有在web应用的Spring ApplicationContext中生效。

session

一个bean定义代表对应bean的作用域与Http Session的生命周期相同。只有在web应用的Spring ApplicationContext中生效。

application

一个bean定义代表对应bean的作用域与ServletContext的生命周期相同。 只有在web应用的Spring ApplicationContext中生效。

websocket

一个bean定义代表对应bean的作用域与WebSocket的生命周期相同。只有在web应用的Spring ApplicationContext中生效。

1.1、Singleton作用域

只有一个共享一个单例bean管理的实例，以及所有bean的请求ID或bean定义ID相匹配的结果在一个特定的Spring容器返回的bean实例。换句话说，当你定义一个作用域为singleton的bean的BeanDefinition，Spring的IoC容器创建一个BeanDefinition定义的实例对象的。这单一实例会被当做单例缓存起来，以后所有后续请求和引用bean返回缓存的对象。

1.2、Prototype作用域

导致每次请求特定bean都会创建一个新的bean实例。即在一个bean注入另一个bean或者请求通过在容器调用getBean()方法的时候。

与其他作用域相比，Spring不管理prototype作用域bean的完整生命周期。容器实例化，配置和组装原型对象并将其交给客户端，而没有该原型实例的进一步记录。因此，尽管无论是什么作用域都会在所有对象上调用初始化生命周期回调方法，但在prototype作用域的情况下，不会调用已配置的销毁生命周期回调。客户端代码必须清理prototype作用域的对象并释放prototype bean所拥有的昂贵资源。要使Spring容器释放prototype的bean所拥有的资源，请尝试使用自定义bean后处理器，它包含对需要清理的bean的引用。

1.3、Request, Session, Application和WebSocket作用域

仅当您使用Spring WebApplicationContext实现（例如XmlWebApplicationContext）时，Request，Session，Application和WebSocket作用域才可用。如果将这些作用域与常规的Spring IoC容器（例如ClassPathXmlApplicationContext）一起使用，则会引发未知bean 作用域的IllegalStateException。

1.3.1、初始Web配置

要在请求，会话，应用程序和websocket级别（Web作用域的bean）支持bean的作用域，在定义bean之前需要一些小的初始配置。 （标准作用域不需要此初始设置：单例和原型。）

如何完成此初始设置取决于您的特定Servlet环境。

如果您在Spring Web MVC中访问scoped bean，实际上是在Spring DispatcherServlet处理的请求中，则无需进行特殊设置。 DispatcherServlet已经公开了所有相关状态。

如果您使用Servlet 2.5 Web容器，并且在Spring的DispatcherServlet之外处理请求（例如，使用JSF或Struts时），则需要注册org.springframework.web.context.request.RequestContextListener ServletRequestListener。对于Servlet 3.0+，可以使用WebApplicationInitializer接口以编程方式完成此操作。或者，如果您的监听器设置存在问题，请考虑使用Spring的RequestContextFilter。 过滤器映射取决于周围的Web应用程序配置，因此您必须根据需要进行更改。 以下清单显示了Web应用程序的过滤器部分：


    ...
    
        requestContextFilter
        org.springframework.web.filter.RequestContextFilter
    
    
        requestContextFilter
        /*
    
    ...

DispatcherServlet，RequestContextListener和RequestContextFilter都完全相同，即将HTTP请求对象绑定到为该请求提供服务的Thread。 这使得请求和会话作用域的bean可以在调用链中进一步使用。

1.3.2、Request作用域 

@RequestScope
@Component
public class LoginAction {
    // ...
}

Spring容器通过对每个HTTP请求使用loginAction bean定义来创建LoginAction bean的新实例。 也就是说，loginAction bean的作用域是HTTP请求级别。 您可以根据需要更改创建的实例的内部状态，因为从同一loginAction bean定义创建的其他实例在状态中看不到这些更改。 当请求完成处理时，将放弃作用于Request作用域的bean。

1.3.3、Session作用域

@SessionScope
@Component
public class UserPreferences {
    // ...
}

Spring容器通过在单个HTTP会话的生存期内使用userPreferences bean定义来创建UserPreferences bean的新实例。 换句话说，userPreferences bean在HTTP会话级别有效地作用域。 与Request作用域的bean一样，您可以根据需要更改创建的实例的内部状态，因为知道同样使用从同一userPreferences bean定义创建的实例的其他HTTP Session实例在状态中看不到这些更改 ，因为它们特定于单个HTTP会话。 最终丢弃HTTP会话时，也会丢弃作用于该特定HTTP会话的bean。

1.3.4、Application作用域

@ApplicationScope
@Component
public class AppPreferences {
    // ...
}

Spring容器通过对整个Web应用程序使用appPreferences bean定义一次来创建AppPreferences bean的新实例。 也就是说，appPreferences bean的作用域是ServletContext级别，并存储为常规的ServletContext属性。 这有点类似于Spring单例bean，但在两个重要方面有所不同：它是每个ServletContext的单例，而不是每个Spring的'ApplicationContext'（在任何给定的Web应用程序中可能有几个），它实际上是暴露的，因此 作为ServletContext属性可见。

1.4、作为依赖的Scoped Bean

Spring IoC容器不仅管理对象（bean）的实例化，还管理依赖关系。 如果要将（例如）HTTP Request作用域的bean注入到寿命较长作用域的另一个bean中，您可以选择注入AOP代理来代替作用域内的bean。 也就是说，您需要注入一个代理对象，该对象公开与作用域对象相同的公共接口，但也可以从相关作用域（例如HTTP请求）中检索真实目标对象，并将方法调用委托给真实对象。

您还可以在作为单例的作用域的bean之间使用(注解方式为@Scope(proxyMode=ScopedProxyMode.TARGET_CLASS))，然后引用通过可序列化的中间代理，从而能够在反序列化时重新获取目标单例bean。

当针对原型作用域的bean声明时，共享代理上的每个方法调用都会导致创建一个新的目标实例，然后将该调用转发到该目标实例。

要创建此类代理，请将子元素插入到作用域bean定义中。 为什么在Request，Session和自定义范作用域别定义bean的定义需要元素？ 考虑以下单例bean定义，并将其与您需要为上述作用域定义的内容进行对比（请注意，以下userPreferences bean定义不完整）：

 在前面的示例中，单例bean（userManager）注入了对HTTP会话作用域的bean（userPreferences）的引用。这里的重点是userManager bean是一个单例：它每个容器只实例化一次，它的依赖项（在这种情况下只有一个，userPreferences bean）也只注入一次。这意味着userManager bean仅在完全相同的userPreferences对象（即最初注入它的对象）上运行。

当将一个寿命较短的scoped bean注入一个寿命较长的scoped bean时，这不是你想要的行为（例如，将一个HTTP Session-scoped协作bean作为依赖注入singleton bean）。相反，您需要一个userManager对象，并且，对于HTTP会话的生命周期，您需要一个特定于HTTP会话的userPreferences对象。因此，容器创建一个对象，该对象公开与UserPreferences类（理想情况下是UserPreferences实例的对象）完全相同的公共接口，该对象可以从作用域机制（HTTP请求，会话等）获取真实的UserPreferences对象。 容器将此代理对象注入userManager bean，该bean不知道此UserPreferences引用是代理。在此示例中，当UserManager实例在依赖注入的UserPreferences对象上调用方法时，它实际上是在代理上调用方法。然后，代理从（在这种情况下）HTTP会话中获取真实的UserPreferences对象，并将方法调用委托给检索到的真实UserPreferences对象。

因此，在将请求和会话作用域的bean注入协作对象时，您需要以下（正确和完整）配置，如以下示例所示：

选择要创建的代理类型
默认情况下，当Spring容器为使用元素或@RequestScope标记的bean创建代理时，将创建基于CGLIB的类代理。

CGLIB代理只拦截公共方法调用！ 不要在这样的代理上调用非公共方法。 它们不会委托给实际的作用域目标对象。

或者，您可以通过为元素的proxy-target-class属性的值指定false或@RequestScope(proxyMode=ScopedProxyMode.INTERFACES)，将Spring容器配置为为此类作用域bean创建基于JDK接口的标准代理。 使用基于JDK接口的代理意味着您不需要在应用程序类路径中使用其他库来影响此类代理。 但是，这也意味着作用域bean的类必须至少实现一个接口，并且注入了作用域bean的所有协作者必须通过其中一个接口引用bean。 以下示例显示了基于接口的代理： 

 1.5、自定义作用域

要将自定义作用域集成到Spring容器中，需要实现org.springframework.beans.factory.config.Scope接口。Scope接口是ConfigurableBeanFactory使用的策略接口， 表示保存bean实例的目标作用域。 这允许扩展BeanFactory的标准作用域(“singleton”和“prototype”)自定义的其他作用域，注册为ConfigurableBeanFactory#registerScope(String,Scope)特定键。
 ApplicationContext实现例如WebApplicationContext 可以注册特定于其环境的其他标准作用域， 例如“request” 和“session”，
 基于此Scope SPI。
即使它主要用于Web环境中的扩展作用域， 这个SPI是完全通用的：它提供了获取和放置的能力来自任何底层存储机制的对象，例如HTTP会话 或自定义会话机制。传入此类的名称get()和remove()方法将识别出来当前作用域内的目标对象。
Scope实现应该是线程安全的。 一个Scope实例可以与多个bean工厂一起使用 同时，如果需要（除非明确要注意包含BeanFactory），可以访问任意数量的线程来自任意数量工厂的Scope。

Scope接口有四种方法可以从作用域中获取对象，从作用域中删除它们，然后将它们销毁。

public interface Scope {
   //如果在底层存储机制中找不到，则从基础作用域返回具有给定名称的对象，ObjectFactory.getObject()创建它
   //这是Scope的核心操作，也是唯一绝对需要的操作。
   Object get(String name, ObjectFactory objectFactory);
   //从基础作用域中删除具有给定name的对象。如果没有找到对象，则返回{@code null}; 否则返回已删除Object
   //请注意，实现还应删除指定对象的已注册销毁回调（如果有）。 
   //但是，在这种情况下，不需要执行已注册的销毁回调，因为对象将被调用者销毁（如果适用）。
   //注意：这是可选操作。 如果实现不支持显式删除对象，则可能会抛出UnsupportedOperationException
   @Nullable
   Object remove(String name);
   //注册要在作用域内销毁指定对象时执行的回调（或者在破坏整个作用域时，如果作用域不破坏单个对象，而只是完全终止）。
   //注意：这是一个可选操作。只有具有实际销毁配置的scoped bean（DisposableBean，destroy-method，DestructionAwareBeanPostProcessor）才会调用此方法。
   //实现应该尽力在适当的时间执行给定的回调。如果底层运行时环境根本不支持这样的回调，则必须忽略回调并记录相应的警告。
   //请注意，“销毁”是指将对象自动销毁为作用域自身生命周期的一部分，而不是个人应用程序已明确删除了作用域对象。
   //如果通过此facade的remove(String)方法删除了作用域对象，则也应删除任何已注册的销毁回调，假设删除的对象将被重用或手动销毁
   void registerDestructionCallback(String name, Runnable callback);
   //解析给定键的上下文对象（如果有）。例如。 键“request”的HttpServletRequest对象。
   @Nullable
   Object resolveContextualObject(String key);
   //返回当前基础作用域的会话ID（如果有）。会话ID的确切含义取决于底层存储机制。 
   //对于会话作用域的对象，会话ID通常等于（或派生自）HttpSession＃getId（）会话ID; 
   //对于位于整个会话中的自定义会话，当前会话的特定ID将是合适的。
   //注意：这是可选操作。 如果底层存储机制没有明显的此类ID候选者，则在此方法的实现中返回null是完全有效的。
   @Nullable
   String getConversationId();
}

假设您编写自定义Scope实现，然后按照下一个示例中的说明进行注册。

下一个示例使用SimpleThreadScope，它包含在Spring中，但默认情况下未注册。 对于您自己的自定义Scope实现，指令是相同的。

Scope threadScope = new SimpleThreadScope();
beanFactory.registerScope("thread", threadScope);

然后，您可以创建符合自定义Scope的作用域规则的bean定义，如下所示：

使用自定义Scope实现，您不仅限于作用域的编程注册。 您还可以使用CustomScopeConfigurer类以声明方式执行Scope注册，如以下示例所示：   


    
        
            
                
            
        
   

当您在FactoryBean实现中放置时，它是作用域的工厂bean本身，而不是从getObject()返回的对象。

2、Spring作用域的实现

Spring Bean的每种作用域都有一种与之对应的Scope实例来管理它的生命周期，这些Scope实例通常在Spring容器启动的时候注册到容器中。

2.1、Scope实现类的注册

AbstractApplicationContext在refresh()方法调用时会触发postProcessBeanFactory()方法，默认为空实现，WebApplicationContext的实现类会重写此方法，如AbstractRefreshableWebApplicationContext。

@Override
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
   beanFactory.ignoreDependencyInterface(ServletContextAware.class);
   beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
   //这里注册Scope实例
   WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
   WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
//使用WebApplicationContext使用的给定BeanFactory注册特定于Web的作用域
//（“request”，“session”，“globalSession”，“application”）。
public static void registerWebApplicationScopes(ConfigurableListableBeanFactory beanFactory,
      @Nullable ServletContext sc) {
   beanFactory.registerScope(WebApplicationContext.SCOPE_REQUEST, new RequestScope());
   beanFactory.registerScope(WebApplicationContext.SCOPE_SESSION, new SessionScope());
   if (sc != null) {
      ServletContextScope appScope = new ServletContextScope(sc);
      beanFactory.registerScope(WebApplicationContext.SCOPE_APPLICATION, appScope);
      // Register as ServletContext attribute, for ContextCleanupListener to detect it.
      sc.setAttribute(ServletContextScope.class.getName(), appScope);
   }
   beanFactory.registerResolvableDependency(ServletRequest.class, new RequestObjectFactory());
   beanFactory.registerResolvableDependency(ServletResponse.class, new ResponseObjectFactory());
   beanFactory.registerResolvableDependency(HttpSession.class, new SessionObjectFactory());
   beanFactory.registerResolvableDependency(WebRequest.class, new WebRequestObjectFactory());
   if (jsfPresent) {
      FacesDependencyRegistrar.registerFacesDependencies(beanFactory);
   }
}

这里AbstractRefreshableWebApplicationContext注册了三种Scope实例:

  • RequestScope：request作用域的实现。
  • SessionScope：session作用域的实现。
  • ServletContextScope：application作用域的实现。

下图Spring默认给出的Scope实现。

【Spring源码分析】34-Spring Bean作用域的设计与实现_第1张图片

AbstractRequestAttributesScope是Scope抽象实现，它从当前线程绑定的RequestAttributes对象中的特定作用域读取。
子类只需要实现getScope()来指示此类RequestAttributes作用域从中读取属性。
子类可能希望覆盖get()和remove()方法，以便在回调中将同步添加到此超类中。

public abstract class AbstractRequestAttributesScope implements Scope {
   @Override
   public Object get(String name, ObjectFactory objectFactory) {
      RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
      Object scopedObject = attributes.getAttribute(name, getScope());
      if (scopedObject == null) {
         scopedObject = objectFactory.getObject();
         attributes.setAttribute(name, scopedObject, getScope());
         // Retrieve object again, registering it for implicit session attribute updates.
         // As a bonus, we also allow for potential decoration at the getAttribute level.
         Object retrievedObject = attributes.getAttribute(name, getScope());
         if (retrievedObject != null) {
            // Only proceed with retrieved object if still present (the expected case).
            // If it disappeared concurrently, we return our locally created instance.
            scopedObject = retrievedObject;
         }
      }
      return scopedObject;
   }
   @Override
   @Nullable
   public Object remove(String name) {
      RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
      Object scopedObject = attributes.getAttribute(name, getScope());
      if (scopedObject != null) {
         attributes.removeAttribute(name, getScope());
         return scopedObject;
      }
      else {
         return null;
      }
   }
   @Override
   public void registerDestructionCallback(String name, Runnable callback) {
      RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
      attributes.registerDestructionCallback(name, callback, getScope());
   }
   @Override
   @Nullable
   public Object resolveContextualObject(String key) {
      RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
      return attributes.resolveReference(key);
   }
   //RequestScope返回RequestAttributes#SCOPE_REQUEST
   //SessionScope返回RequestAttributes#SCOPE_SESSION
   protected abstract int getScope();
}

AbstractRequestAttributesScope是RequestScope和SessionScope的父类，实现了核心方法get()，这个方法用于创建Scoped bean，大致逻辑是从RequestContextHolder中获取与当前线程绑定的RequestAttributes对象，如果这个bean的name存在于RequestAttributes中则直接返回，否则使用外部传来的ObjectFactory创建一个对象放入与当前线程绑定的RequestAttributes对象中。

上面这个过程有两个问题需要解决：

  • get()方法何时被调用
  • RequestAttributes对象何时与当前线程的RequestContextHolder绑定

对于问题一，是在bean创建的阶段被调用的，换句话说就是AbstractBeanFactory的doGetBean()方法调用时：

【Spring源码分析】34-Spring Bean作用域的设计与实现_第2张图片

在Bean的创建过程中，会判断如果此Bean是scoped的，会调用此bean对应scope实例的registerDestructionCallback()方法，实现代码在AbstractAutowireCapableBeanFactory.doCreateBean()中。

【Spring源码分析】34-Spring Bean作用域的设计与实现_第3张图片

//将给定的bean添加到此工厂中的一次性Bean列表中，
//注册其DisposableBean接口和/或在工厂关闭时调用的给定destroy方法（如果适用）。 
//仅适用于singleton和scoped的bean
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, getBeanPostProcessors(), acc));
      }
      else {
         //这个scopes保存着容器中通过registerScope()方法注册的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, getBeanPostProcessors(), acc));
      }
   }
}

对于bean的具体创建过程可以参考《BeanFactory的实现》。

从registerDisposableBeanIfNecessary()方法的实现可以看到，Scope会为这个bean注册一个DisposableBeanAdapter，从上面AbstractRequestAttributesScope的registerDestructionCallback()方法实现可知，此DisposableBeanAdapter也会放入与当前线程绑定的RequestAttributes对象中，那么问题又来了：此DisposableBeanAdapter何时会被执行呢？

下面我们将这个问题和RequestAttributes对象何时与当前线程的RequestContextHolder绑定一起解答。

2.2、Scoped Bean生命周期过程

从上面概述了解到request、session、application这三种bean作用域只有在web环境下才可以使用，这里就以Spring MVC为例进行讲解。

我们知道Spring MVC有个中央控制器DispatcherServlet负责协调和组织不同组件完成请求处理并返回响应工作，它继承于FrameworkServlet，本身也是一个Servlet重写了service()方法，并将请求处理交给了processRequest()方法。

@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
   if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
      processRequest(request, response);
   }
   else {
      super.service(request, response);
   }
}
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {
   long startTime = System.currentTimeMillis();
   Throwable failureCause = null;
   LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
   LocaleContext localeContext = buildLocaleContext(request);

   RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
   //这里是创建RequestAttributes的地方
   ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

   WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
   asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
   //然后这里使用LocaleContextHolder将当前线程与requestAttributes绑定
   initContextHolders(request, localeContext, requestAttributes);
   try {//这里是具体处理请丢的逻辑
      doService(request, response);
   }
   catch (ServletException | IOException ex) {
      failureCause = ex;
      throw ex;
   }
   catch (Throwable ex) {
      failureCause = ex;
      throw new NestedServletException("Request processing failed", ex);
   }
   finally {
      //还原previousAttributes，保证当前请求处理完就将bean从当前线程移除
      resetContextHolders(request, previousLocaleContext, previousAttributes);
      if (requestAttributes != null) {
         requestAttributes.requestCompleted();
      }
      logResult(request, response, failureCause, asyncManager);
      //这里会发送一个请求处理完毕事件，感兴趣的话可以接收
      publishRequestHandledEvent(request, response, startTime, failureCause);
   }
}

 从上面的代码得知，当一个请求到来buildRequestAttributes()方法会创建一个ServletRequestAttributes与当前线程绑定，解答了上面的一个问题：RequestAttributes对象何时与当前线程的RequestContextHolder绑定。

下面解答第二个问题DisposableBeanAdapter何时会被执行呢？

在processRequest()方法的finally代码块中调用requestAttributes.requestCompleted()，这里会将RequestAttributes对象通过registerRequestDestructionCallback()方法注册的回调函数也就是上面提到DisposableBeanAdapter执行一遍。

//执行所有请求销毁回调并更新在请求处理期间访问的会话属性。
public void requestCompleted() {
   //执行请求完成后已注册执行的所有回调。
   executeRequestDestructionCallbacks();
   //更新在请求处理期间访问过的所有会话属性，以将其可能更新的状态公开给基础会话管理器。
   updateAccessedSessionAttributes();
   this.requestActive = false;
}
private void executeRequestDestructionCallbacks() {
   synchronized (this.requestDestructionCallbacks) {
      for (Runnable runnable : this.requestDestructionCallbacks.values()) {
         runnable.run();
      }
      this.requestDestructionCallbacks.clear();
   }
}

下面看一看DisposableBeanAdapter的具体代码。

在AbstractAutowireCapableBeanFactory中的registerDisposableBeanIfNecessary()方法中使用了五个参数的构造方法来实例化DisposableBeanAdapter。

public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
      List postProcessors, @Nullable AccessControlContext acc) {

   Assert.notNull(bean, "Disposable bean must not be null");
   this.bean = bean;
   this.beanName = beanName;
   this.invokeDisposableBean =
         (this.bean instanceof DisposableBean && !beanDefinition.isExternallyManagedDestroyMethod("destroy"));
   this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
   this.acc = acc;
   String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
   if (destroyMethodName != null && !(this.invokeDisposableBean && "destroy".equals(destroyMethodName)) &&
         !beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
      this.destroyMethodName = destroyMethodName;
      this.destroyMethod = determineDestroyMethod(destroyMethodName);
      if (this.destroyMethod == null) {
         if (beanDefinition.isEnforceDestroyMethod()) {
            throw new BeanDefinitionValidationException("Could not find a destroy method named '" +
                  destroyMethodName + "' on bean with name '" + beanName + "'");
         }
      }
      else {
         Class[] paramTypes = this.destroyMethod.getParameterTypes();
         if (paramTypes.length > 1) {
            throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                  beanName + "' has more than one parameter - not supported as destroy method");
         }
         else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
            throw new BeanDefinitionValidationException("Method '" + destroyMethodName + "' of bean '" +
                  beanName + "' has a non-boolean parameter - not supported as destroy method");
         }
      }
   }
   this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
}

这个构造函数主要是保存bean的destroy方法，这个destroy方法可以是bean的destroy-method、@PreDestroy，和容器中能处理此bean的DestructionAwareBeanPostProcessor。

@Nullable
private List filterPostProcessors(List processors, Object bean) {
   List filteredPostProcessors = null;
   if (!CollectionUtils.isEmpty(processors)) {
      filteredPostProcessors = new ArrayList<>(processors.size());
      for (BeanPostProcessor processor : processors) {
         if (processor instanceof DestructionAwareBeanPostProcessor) {
            DestructionAwareBeanPostProcessor dabpp = (DestructionAwareBeanPostProcessor) processor;
            if (dabpp.requiresDestruction(bean)) {
               filteredPostProcessors.add(dabpp);
            }
         }
      }
   }
   return filteredPostProcessors;
}

下面看run()方法和destroy()的实现。

@Override
public void run() {
   destroy();
}

@Override
public void destroy() {
   if (!CollectionUtils.isEmpty(this.beanPostProcessors)) {
      for (DestructionAwareBeanPostProcessor processor : this.beanPostProcessors) {
         processor.postProcessBeforeDestruction(this.bean, this.beanName);
      }
   }
   if (this.invokeDisposableBean) {
      if (logger.isTraceEnabled()) {
         logger.trace("Invoking destroy() on bean with name '" + this.beanName + "'");
      }
      try {
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedExceptionAction) () -> {
               ((DisposableBean) this.bean).destroy();
               return null;
            }, this.acc);
         }
         else {
            ((DisposableBean) this.bean).destroy();
         }
      }
      catch (Throwable ex) {
         String msg = "Invocation of destroy method failed on bean with name '" + this.beanName + "'";
         if (logger.isDebugEnabled()) {
            logger.info(msg, ex);
         }
         else {
            logger.info(msg + ": " + ex);
         }
      }
   }
   if (this.destroyMethod != null) {
      invokeCustomDestroyMethod(this.destroyMethod);
   }
   else if (this.destroyMethodName != null) {
      Method methodToCall = determineDestroyMethod(this.destroyMethodName);
      if (methodToCall != null) {
         invokeCustomDestroyMethod(methodToCall);
      }
   }
} 
  
2.3、ScopedProxyFactoryBean实现原理
 
  
在1.4节中提到如果Scoped Bean不是直接通过容器通过getBean()获取的，而是作为一个依赖注入到其他bean中，这时需要使用或@Scope(proxyMode=ScopedProxyMode.INTERFACES)或@Scope(proxyMode=ScopedProxyMode.TARGET_CLASS)，原因在1.4节中已经说明了，下面看代码的实现过程。
 
  
这里已注解的形式说明实现原理。
 
  
在进行@Conponent注解扫描的时候会调用ClassPathBeanDefinitionScanner#doScan()方法，这个方法内部使用ScopeMetadataResolver读取bean类上面的@Scope注解，如果存在此注解则使用ScopedProxyCreator#createScopedProxy()方法定义一个ScopedProxyFactoryBean的BeanDefinition，他是一个FactoryBean，getObject()返回的就是这个bean的代理，Spring容器注入的时候也就使用的是这个代理了。
 
  
【Spring源码分析】34-Spring Bean作用域的设计与实现_第4张图片
 
  
【Spring源码分析】34-Spring Bean作用域的设计与实现_第5张图片
 
  
【Spring源码分析】34-Spring Bean作用域的设计与实现_第6张图片
 
  
Spring在装配bean阶段会将原始bean的bean name设置到ScopedProxyFactoryBean中通过setTargetBeanName()方法，在这个方法中会使用成员实例scopedTargetSource保存bean name，这个scopedTargetSource在setBeanFactory()方法调用的时候保存BeanFactory，这样在scopedTargetSource的getTarget()方法被调用的时候就直接委托给BeanFactory的getBean()方法，这就保证了scoped bean如果当前线程还存在则直接返回否则就创建一个新的bean。
 
  
public class ScopedProxyFactoryBean extends ProxyConfig
      implements FactoryBean, BeanFactoryAware, AopInfrastructureBean {
   /** The TargetSource that manages scoping. */
   private final SimpleBeanTargetSource scopedTargetSource = new SimpleBeanTargetSource();
   /** The name of the target bean. */
   @Nullable
   private String targetBeanName;
   /** The cached singleton proxy. */
   @Nullable
   private Object proxy;
   /**
    * Create a new ScopedProxyFactoryBean instance.
    */
   public ScopedProxyFactoryBean() {
      setProxyTargetClass(true);
   }
   /**
    * Set the name of the bean that is to be scoped.
    */
   public void setTargetBeanName(String targetBeanName) {
      this.targetBeanName = targetBeanName;
      this.scopedTargetSource.setTargetBeanName(targetBeanName);
   }
   @Override
   public void setBeanFactory(BeanFactory beanFactory) {
      if (!(beanFactory instanceof ConfigurableBeanFactory)) {
         throw new IllegalStateException("Not running in a ConfigurableBeanFactory: " + beanFactory);
      }
      ConfigurableBeanFactory cbf = (ConfigurableBeanFactory) beanFactory;
      this.scopedTargetSource.setBeanFactory(beanFactory);
      ProxyFactory pf = new ProxyFactory();
      pf.copyFrom(this);
      pf.setTargetSource(this.scopedTargetSource);
      Assert.notNull(this.targetBeanName, "Property 'targetBeanName' is required");
      Class beanType = beanFactory.getType(this.targetBeanName);
      if (beanType == null) {
         throw new IllegalStateException("Cannot create scoped proxy for bean '" + this.targetBeanName +
               "': Target type could not be determined at the time of proxy creation.");
      }
      if (!isProxyTargetClass() || beanType.isInterface() || Modifier.isPrivate(beanType.getModifiers())) {
         pf.setInterfaces(ClassUtils.getAllInterfacesForClass(beanType, cbf.getBeanClassLoader()));
      }
      // Add an introduction that implements only the methods on ScopedObject.
      ScopedObject scopedObject = new DefaultScopedObject(cbf, this.scopedTargetSource.getTargetBeanName());
      pf.addAdvice(new DelegatingIntroductionInterceptor(scopedObject));
      // Add the AopInfrastructureBean marker to indicate that the scoped proxy
      // itself is not subject to auto-proxying! Only its target bean is.
      pf.addInterface(AopInfrastructureBean.class);
      this.proxy = pf.getProxy(cbf.getBeanClassLoader());
   }
   @Override
   public Object getObject() {
      if (this.proxy == null) {
         throw new FactoryBeanNotInitializedException();
      }
      return this.proxy;
   }
   @Override
   public Class getObjectType() {
      if (this.proxy != null) {
         return this.proxy.getClass();
      }
      return this.scopedTargetSource.getTargetClass();
   }
   @Override
   public boolean isSingleton() {
      return true;
   }
} 
  
这个ScopedProxyFactoryBean使用了ProxyFactory生成代理对象，我们以JdkDynamicAopProxy为例说明。在代理方法被调用的时候会触发JdkDynamicAopProxy的invoke()方法，这个方法中获取目标对象就是通过ScopedProxyFactoryBean的scopedTargetSource获取的从而保证了每次方法被调用的时候都会创建(如果超出了作用域)一个对象。
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 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
    
                    
    • 
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • 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
    
                    
    • 
                    
  • 【C#生态园】深度剖析：C#嵌入式开发工具大揭秘
                        friklogff
C#生态园c#开发语言
                        
    C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • 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，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • 软件测试/测试开发/全日制 |利用Django REST framework构建微服务
                        霍格沃兹-慕漓
django微服务sqlite
                        
    霍格沃兹测试开发学社推出了《Python全栈开发与自动化测试班》。本课程面向开发人员、测试人员与运维人员，课程内容涵盖Python编程语言、人工智能应用、数据分析、自动化办公、平台开发、UI自动化测试、接口测试、性能测试等方向。为大家提供更全面、更深入、更系统化的学习体验，课程还增加了名企私教服务内容，不仅有名企经理为你1v1辅导，还有行业专家进行技术指导，针对性地解决学习、工作中遇到的难题。让找
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •