shallowinggg
shallowinggg

# 源码解析：AOP（2）

接上篇# 源码解析：AOP

cglib类代理

使用cglib实现的代理与jdk代理类似，只是代理对象的构造方式不同。

public Object getProxy(@Nullable ClassLoader classLoader) {
   if (logger.isTraceEnabled()) {
      logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
   }

   try {
      Class rootClass = this.advised.getTargetClass();
      Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");

      Class proxySuperClass = rootClass;
      // 如果目标类已是cglib生成的代理类，那么继续向上查找
      if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
         proxySuperClass = rootClass.getSuperclass();
         Class[] additionalInterfaces = rootClass.getInterfaces();
         for (Class additionalInterface : additionalInterfaces) {
            this.advised.addInterface(additionalInterface);
         }
      }

      // Validate the class, writing log messages as necessary.
      // 验证方法，如果存在无法继承的方法，如final，static，打印日志信息
      validateClassIfNecessary(proxySuperClass, classLoader);

      // Configure CGLIB Enhancer...
      Enhancer enhancer = createEnhancer();
      if (classLoader != null) {
         enhancer.setClassLoader(classLoader);
         if (classLoader instanceof SmartClassLoader &&
               ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
            enhancer.setUseCache(false);
         }
      }
      enhancer.setSuperclass(proxySuperClass);
      enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
      enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
      // 使用入参给定的类加载器加载类，如果不为空
      enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

      // 获取回调，即各种方法拦截器
      Callback[] callbacks = getCallbacks(rootClass);
      Class[] types = new Class[callbacks.length];
      for (int x = 0; x < types.length; x++) {
         types[x] = callbacks[x].getClass();
      }
      // fixedInterceptorMap only populated at this point, after getCallbacks call above
      enhancer.setCallbackFilter(new ProxyCallbackFilter(
            this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
      enhancer.setCallbackTypes(types);

      // Generate the proxy class and create a proxy instance.
      return createProxyClassAndInstance(enhancer, callbacks);
   }
   catch (CodeGenerationException | IllegalArgumentException ex) {
      throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
            ": Common causes of this problem include using a final class or a non-visible class",
            ex);
   }
   catch (Throwable ex) {
      // TargetSource.getTarget() failed
      throw new AopConfigException("Unexpected AOP exception", ex);
   }
}

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
   enhancer.setInterceptDuringConstruction(false);
   enhancer.setCallbacks(callbacks);
   return (this.constructorArgs != null && this.constructorArgTypes != null ?
         enhancer.create(this.constructorArgTypes, this.constructorArgs) :
         enhancer.create());
}

Spring使用ObjenesisCglibAopProxy拓展了CglibAopProxy，并从4.0开始作为默认选项。它覆写了CglibAopProxy的createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks)方法，使用Objenesis创建cglib代理对象。

protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
   Class proxyClass = enhancer.createClass();
   Object proxyInstance = null;

   // 默认为true，可以指定spring.objenesis.ignore为true使其返回false
   if (objenesis.isWorthTrying()) {
      try {
         proxyInstance = objenesis.newInstance(proxyClass, enhancer.getUseCache());
      }
      catch (Throwable ex) {
         logger.debug("Unable to instantiate proxy using Objenesis, " +
               "falling back to regular proxy construction", ex);
      }
   }

   if (proxyInstance == null) {
      // Regular instantiation via default constructor...
      try {
         Constructor ctor = (this.constructorArgs != null ?
               proxyClass.getDeclaredConstructor(this.constructorArgTypes) :
               proxyClass.getDeclaredConstructor());
         ReflectionUtils.makeAccessible(ctor);
         proxyInstance = (this.constructorArgs != null ?
               ctor.newInstance(this.constructorArgs) : ctor.newInstance());
      }
      catch (Throwable ex) {
         throw new AopConfigException("Unable to instantiate proxy using Objenesis, " +
               "and regular proxy instantiation via default constructor fails as well", ex);
      }
   }

   ((Factory) proxyInstance).setCallbacks(callbacks);
   return proxyInstance;
}

createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks)方法中较为重要的部分是getCallbacks方法的调用，此方法的作用是获取方法拦截器，以增强对应的方法。

private Callback[] getCallbacks(Class rootClass) throws Exception {
   // Parameters used for optimization choices...
   boolean exposeProxy = this.advised.isExposeProxy();
   // 默认为false
   boolean isFrozen = this.advised.isFrozen();
   // 一般为true
   boolean isStatic = this.advised.getTargetSource().isStatic();

   // Choose an "aop" interceptor (used for AOP calls).
   Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

   // Choose a "straight to target" interceptor. (used for calls that are
   // unadvised but can return this). May be required to expose the proxy.
   Callback targetInterceptor;
   if (exposeProxy) {
      targetInterceptor = (isStatic ?
            new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
            new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
   }
   else {
      targetInterceptor = (isStatic ?
            new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
            new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
   }

   // Choose a "direct to target" dispatcher (used for
   // unadvised calls to static targets that cannot return this).
   Callback targetDispatcher = (isStatic ?
         new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());

   Callback[] mainCallbacks = new Callback[] {
         aopInterceptor,  // for normal advice
         targetInterceptor,  // invoke target without considering advice, if optimized
         new SerializableNoOp(),  // no override for methods mapped to this
         targetDispatcher, this.advisedDispatcher,
         new EqualsInterceptor(this.advised),
         new HashCodeInterceptor(this.advised)
   };

   Callback[] callbacks;

   // If the target is a static one and the advice chain is frozen,
   // then we can make some optimizations by sending the AOP calls
   // direct to the target using the fixed chain for that method.
   if (isStatic && isFrozen) {
      Method[] methods = rootClass.getMethods();
      Callback[] fixedCallbacks = new Callback[methods.length];
      this.fixedInterceptorMap = new HashMap<>(methods.length);

      // TODO: small memory optimization here (can skip creation for methods with no advice)
      for (int x = 0; x < methods.length; x++) {
         Method method = methods[x];
         List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
         fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
               chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
         this.fixedInterceptorMap.put(method, x);
      }

      // Now copy both the callbacks from mainCallbacks
      // and fixedCallbacks into the callbacks array.
      callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
      System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
      System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
      this.fixedInterceptorOffset = mainCallbacks.length;
   }
   else {
      callbacks = mainCallbacks;
   }
   return callbacks;
}

 
 
其中主要的callbacks如下：
 
 
Callback[] mainCallbacks = new Callback[] {
    aopInterceptor,  // for normal advice
    targetInterceptor,  // invoke target without considering advice, if optimized
    new SerializableNoOp(),  // no override for methods mapped to this
    targetDispatcher, this.advisedDispatcher,
    new EqualsInterceptor(this.advised),
    new HashCodeInterceptor(this.advised)
};

 
 
aopInterceptor用于获取拦截器链，然后进行组合并调用。
 
 
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
   Object oldProxy = null;
   boolean setProxyContext = false;
   Object target = null;
   TargetSource targetSource = this.advised.getTargetSource();
   try {
      if (this.advised.exposeProxy) {
         // Make invocation available if necessary.
         oldProxy = AopContext.setCurrentProxy(proxy);
         setProxyContext = true;
      }
      // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
      target = targetSource.getTarget();
      Class targetClass = (target != null ? target.getClass() : null);
      List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
      Object retVal;
      // Check whether we only have one InvokerInterceptor: that is,
      // no real advice, but just reflective invocation of the target.
      if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
         // We can skip creating a MethodInvocation: just invoke the target directly.
         // Note that the final invoker must be an InvokerInterceptor, so we know
         // it does nothing but a reflective operation on the target, and no hot
         // swapping or fancy proxying.
         Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
         retVal = methodProxy.invoke(target, argsToUse);
      }
      else {
         // We need to create a method invocation...
         retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
      }
      retVal = processReturnType(proxy, target, method, retVal);
      return retVal;
   }
   finally {
      if (target != null && !targetSource.isStatic()) {
         targetSource.releaseTarget(target);
      }
      if (setProxyContext) {
         // Restore old proxy.
         AopContext.setCurrentProxy(oldProxy);
      }
   }
}

 
 
targetInterceptor用于没有advice的情况，根据静动态和exposeProxy分为四种，下面是静态的两种：
 
 
private static class StaticUnadvisedInterceptor implements MethodInterceptor, Serializable {

   @Nullable
   private final Object target;

   public StaticUnadvisedInterceptor(@Nullable Object target) {
      this.target = target;
   }

   @Override
   @Nullable
   public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      Object retVal = methodProxy.invoke(this.target, args);
      return processReturnType(proxy, this.target, method, retVal);
   }
}


private static class StaticUnadvisedExposedInterceptor implements MethodInterceptor, Serializable {

   @Nullable
   private final Object target;

   public StaticUnadvisedExposedInterceptor(@Nullable Object target) {
      this.target = target;
   }

   @Override
   @Nullable
   public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
      Object oldProxy = null;
      try {
         oldProxy = AopContext.setCurrentProxy(proxy);
         Object retVal = methodProxy.invoke(this.target, args);
         return processReturnType(proxy, this.target, method, retVal);
      }
      finally {
         AopContext.setCurrentProxy(oldProxy);
      }
   }
}


 
 
其他类型的callback不多描述，具体调用哪一个callback由ProxyCallbackFilter决定：
 
 
public int accept(Method method) {
   if (AopUtils.isFinalizeMethod(method)) {
      logger.trace("Found finalize() method - using NO_OVERRIDE");
      return NO_OVERRIDE;
   }
   if (!this.advised.isOpaque() && method.getDeclaringClass().isInterface() &&
         method.getDeclaringClass().isAssignableFrom(Advised.class)) {
      if (logger.isTraceEnabled()) {
         logger.trace("Method is declared on Advised interface: " + method);
      }
      return DISPATCH_ADVISED;
   }
   // We must always proxy equals, to direct calls to this.
   if (AopUtils.isEqualsMethod(method)) {
      if (logger.isTraceEnabled()) {
         logger.trace("Found 'equals' method: " + method);
      }
      return INVOKE_EQUALS;
   }
   // We must always calculate hashCode based on the proxy.
   if (AopUtils.isHashCodeMethod(method)) {
      if (logger.isTraceEnabled()) {
         logger.trace("Found 'hashCode' method: " + method);
      }
      return INVOKE_HASHCODE;
   }
   Class targetClass = this.advised.getTargetClass();
   // Proxy is not yet available, but that shouldn't matter.
   List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
   boolean haveAdvice = !chain.isEmpty();
   boolean exposeProxy = this.advised.isExposeProxy();
   boolean isStatic = this.advised.getTargetSource().isStatic();
   boolean isFrozen = this.advised.isFrozen();
   if (haveAdvice || !isFrozen) {
      // If exposing the proxy, then AOP_PROXY must be used.
      if (exposeProxy) {
         if (logger.isTraceEnabled()) {
            logger.trace("Must expose proxy on advised method: " + method);
         }
         return AOP_PROXY;
      }
      Method key = method;
      // Check to see if we have fixed interceptor to serve this method.
      // Else use the AOP_PROXY.
      if (isStatic && isFrozen && this.fixedInterceptorMap.containsKey(key)) {
         if (logger.isTraceEnabled()) {
            logger.trace("Method has advice and optimizations are enabled: " + method);
         }
         // We know that we are optimizing so we can use the FixedStaticChainInterceptors.
         int index = this.fixedInterceptorMap.get(key);
         return (index + this.fixedInterceptorOffset);
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Unable to apply any optimizations to advised method: " + method);
         }
         return AOP_PROXY;
      }
   }
   else {
      // See if the return type of the method is outside the class hierarchy of the target type.
      // If so we know it never needs to have return type massage and can use a dispatcher.
      // If the proxy is being exposed, then must use the interceptor the correct one is already
      // configured. If the target is not static, then we cannot use a dispatcher because the
      // target needs to be explicitly released after the invocation.
      if (exposeProxy || !isStatic) {
         return INVOKE_TARGET;
      }
      Class returnType = method.getReturnType();
      if (targetClass != null && returnType.isAssignableFrom(targetClass)) {
         if (logger.isTraceEnabled()) {
            logger.trace("Method return type is assignable from target type and " +
                  "may therefore return 'this' - using INVOKE_TARGET: " + method);
         }
         return INVOKE_TARGET;
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Method return type ensures 'this' cannot be returned - " +
                  "using DISPATCH_TARGET: " + method);
         }
         return DISPATCH_TARGET;
      }
   }
}


 
 
cglib代理还提供了一个优化机制，如果isFrozen为true，那么将创建一个固定的拦截链FixedChainStaticTargetInterceptor，因为此时无法调用Advised接口的方法增加或者删除Advise或者Advice，拦截链不会发生改变，因此之后调用方法时将不会每次都进行拦截链的获取。当然，之前在分析jdk代理时发现Spring也对拦截链进行了缓存，不过如果调用了Advised接口中的增加删除方法，那么此缓存将会被移除，下一次调用将会重新获取拦截链。
 
 
if (isStatic && isFrozen) {
   Method[] methods = rootClass.getMethods();
   Callback[] fixedCallbacks = new Callback[methods.length];
   this.fixedInterceptorMap = new HashMap<>(methods.length);

   // TODO: small memory optimization here (can skip creation for methods with no advice)
   for (int x = 0; x < methods.length; x++) {
      Method method = methods[x];
      List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
      fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
            chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
      this.fixedInterceptorMap.put(method, x);
   }

   // Now copy both the callbacks from mainCallbacks
   // and fixedCallbacks into the callbacks array.
   callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
   System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
   System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
   this.fixedInterceptorOffset = mainCallbacks.length;
}

 
 
ProxyFactoryBean
 
 
Spring还提供了一种基于FactoryBean的方式创建代理对象，即ProxyFactoryBean。它对poincut以及其所应用的advisor, advice等等提供了完全的控制。同时，如果你不需要这些特性，它也提供了最简单的配置方式，例如：
 
 

    
    



    






    

    
    
        
            myAdvisor
            debugInterceptor
        
    


 
 
你只需要提供target，即需要被代理的目标对象以及interceptorNames，即用于增强的advisor, advice等即可。
 
 
下面先介绍一下它的各种属性，与之前分析提到的类似：
 
 
     
  
  •  proxyTargetClass: 代理类或者代理接口
    •  
  
  •  optimize: 通过cglib创建代理时是否进行激进的优化，如果不没有完全理解此优化是如何处理的，那么不要使用它。这个属性只对cglib起作用，对jdk代理不起作用。
    •  
  
  •  frozen: 如果设置为true，那么创建代理对象后无法改变拦截链。
    •  
  
  •  exposeProxy: 决定当前代理对象是否能够通过AopContext.currentProxy()暴露给目标对象。
    •  
  
  •  proxyInterfaces: 需要代理的接口。如果不提供，spring会自己查找是否存在可用接口，如果没有则使用cglib代理。
    •  
  
  •  interceptorNames: 需要应用到此代理的Advisor, Advice等的bean名称。可以使用通配符*，表示应用所有Advisor, Advice等；也可以使用xxx*，应用名称前缀为xxx的所有Advisor, Advice。
    •  
  
  •  singleton: 是否只返回一个唯一对象，无论getObject()被调用多少次，默认为true。
    •  
 
 
 
了解了它的属性后，让我们看一下它的核心方法getObject()。
 
 
public Object getObject() throws BeansException {
   // 初始化拦截链
   initializeAdvisorChain();
   // 创建单例或者原型
   if (isSingleton()) {
      return getSingletonInstance();
   }
   else {
      if (this.targetName == null) {
         logger.info("Using non-singleton proxies with singleton targets is often undesirable. " +
               "Enable prototype proxies by setting the 'targetName' property.");
      }
      return newPrototypeInstance();
   }
}

 
 
此方法共分为两步：
 
 
     
  
  1. 初始化拦截器链。根据interceptorNames获取所有匹配的Advisor 
    2.  
  
  2. 根据singleton属性，创建单例或者原型代理对象。
    3.  
 
 
 
private synchronized void initializeAdvisorChain() throws AopConfigException, BeansException {
   if (this.advisorChainInitialized) {
      return;
   }

   // 如果指定了interceptorNames属性
   if (!ObjectUtils.isEmpty(this.interceptorNames)) {
      if (this.beanFactory == null) {
         throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
               "- cannot resolve interceptor names " + Arrays.asList(this.interceptorNames));
      }

      // Globals can't be last unless we specified a targetSource using the property...
      if (this.interceptorNames[this.interceptorNames.length - 1].endsWith(GLOBAL_SUFFIX) &&
            this.targetName == null && this.targetSource == EMPTY_TARGET_SOURCE) {
         throw new AopConfigException("Target required after globals");
      }

      // Materialize interceptor chain from bean names.
      // 实例化拦截器链
      for (String name : this.interceptorNames) {
         if (logger.isTraceEnabled()) {
            logger.trace("Configuring advisor or advice '" + name + "'");
         }

         // 如果为xxx*的形式，则增加所有匹配的Advisor
         if (name.endsWith(GLOBAL_SUFFIX)) {
            if (!(this.beanFactory instanceof ListableBeanFactory)) {
               throw new AopConfigException(
                     "Can only use global advisors or interceptors with a ListableBeanFactory");
            }
            addGlobalAdvisor((ListableBeanFactory) this.beanFactory,
                  name.substring(0, name.length() - GLOBAL_SUFFIX.length()));
         }

         else {
            // If we get here, we need to add a named interceptor.
            // We must check if it's a singleton or prototype.
            Object advice;
            if (this.singleton || this.beanFactory.isSingleton(name)) {
               // Add the real Advisor/Advice to the chain.
               advice = this.beanFactory.getBean(name);
            }
            else {
               // It's a prototype Advice or Advisor: replace with a prototype.
               // Avoid unnecessary creation of prototype bean just for advisor chain initialization.
               advice = new PrototypePlaceholderAdvisor(name);
            }
            addAdvisorOnChainCreation(advice, name);
         }
      }
   }

   this.advisorChainInitialized = true;
}

 
 
initializeAdvisorChain()方法只会被调用一次，从BeanFactory中获取Advisor。如果拦截器名后缀为*，那么将会进行通配符匹配。
 
 
private void addGlobalAdvisor(ListableBeanFactory beanFactory, String prefix) {
   // 获取所有Advisor对象
   String[] globalAdvisorNames =
         BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Advisor.class);
   // 获取所有Interceptor对象，它是Advice的子接口
   String[] globalInterceptorNames =
         BeanFactoryUtils.beanNamesForTypeIncludingAncestors(beanFactory, Interceptor.class);
   List beans = new ArrayList<>(globalAdvisorNames.length + globalInterceptorNames.length);
   Map names = new HashMap<>(beans.size());
   for (String name : globalAdvisorNames) {
      Object bean = beanFactory.getBean(name);
      beans.add(bean);
      names.put(bean, name);
   }
   for (String name : globalInterceptorNames) {
      Object bean = beanFactory.getBean(name);
      beans.add(bean);
      names.put(bean, name);
   }
   // 排序
   AnnotationAwareOrderComparator.sort(beans);
   // 获取匹配的Advisor并增加到拦截器链中
   for (Object bean : beans) {
      String name = names.get(bean);
      if (name.startsWith(prefix)) {
         addAdvisorOnChainCreation(bean, name);
      }
   }
}

private void addAdvisorOnChainCreation(Object next, String name) {
   // We need to convert to an Advisor if necessary so that our source reference
   // matches what we find from superclass interceptors.
   Advisor advisor = namedBeanToAdvisor(next);
   if (logger.isTraceEnabled()) {
      logger.trace("Adding advisor with name '" + name + "'");
   }
   addAdvisor(advisor);
}

public void addAdvisor(Advisor advisor) {
   int pos = this.advisors.size();
   addAdvisor(pos, advisor);
}

@Override
public void addAdvisor(int pos, Advisor advisor) throws AopConfigException {
   if (advisor instanceof IntroductionAdvisor) {
      validateIntroductionAdvisor((IntroductionAdvisor) advisor);
   }
   addAdvisorInternal(pos, advisor);
}

private void addAdvisorInternal(int pos, Advisor advisor) throws AopConfigException {
   Assert.notNull(advisor, "Advisor must not be null");
   if (isFrozen()) {
      throw new AopConfigException("Cannot add advisor: Configuration is frozen.");
   }
   if (pos > this.advisors.size()) {
      throw new IllegalArgumentException(
            "Illegal position " + pos + " in advisor list with size " + this.advisors.size());
   }
   this.advisors.add(pos, advisor);
   updateAdvisorArray();
   adviceChanged();
}

 
 
否则，进行常规的bean获取调用。此处对prototype类型的Advisor进行了一点特殊处理（同时ProxyFactoryBean的singletion属性也需要为false），即只进行占位，并不直接实例化它。
 
 
advice = new PrototypePlaceholderAdvisor(name);

public PrototypePlaceholderAdvisor(String beanName) {
   this.beanName = beanName;
   this.message = "Placeholder for prototype Advisor/Advice with bean name '" + beanName + "'";
}


 
 
单例
 
 
单例对象只创建一次，创建完成后将被缓存，之后每次调用都返回此对象。
 
 
private synchronized Object getSingletonInstance() {
   if (this.singletonInstance == null) {
      // 获取TargetSource
      this.targetSource = freshTargetSource();
      // 自动检测接口
      if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
         // Rely on AOP infrastructure to tell us what interfaces to proxy.
         Class targetClass = getTargetClass();
         if (targetClass == null) {
            throw new FactoryBeanNotInitializedException("Cannot determine target class for proxy");
         }
         setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
      }
      // Initialize the shared singleton instance.
      super.setFrozen(this.freezeProxy);
      // 创建代理对象
      this.singletonInstance = getProxy(createAopProxy());
   }
   return this.singletonInstance;
}


 
 
获取TargetSource分两种情况，第一种情况也是最常见的情况为指定了target属性，此时Spring将会从容器中获取此bean并将它包装为TargetSource对象（默认为SingletonTargetSource），当然，如果这个bean已经是TargetSource对象，那么只需要执行转换即可。第二种情况则是指定了targetSource属性，此时可以直接返回此对象。通过第二种方式，你可以自定义需要的TargetSource或者使用Spring提供的几个TargetSource（比如common，threadlocal等），以达成相应的需求。
 
 
private TargetSource freshTargetSource() {
   if (this.targetName == null) {
      if (logger.isTraceEnabled()) {
         logger.trace("Not refreshing target: Bean name not specified in 'interceptorNames'.");
      }
      return this.targetSource;
   }
   else {
      if (this.beanFactory == null) {
         throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
               "- cannot resolve target with name '" + this.targetName + "'");
      }
      if (logger.isDebugEnabled()) {
         logger.debug("Refreshing target with name '" + this.targetName + "'");
      }
      Object target = this.beanFactory.getBean(this.targetName);
      return (target instanceof TargetSource ? (TargetSource) target : new SingletonTargetSource(target));
   }
}


 
 
接下来，如果你没有设置proxyInterfaces属性，那么Spring将会自动检查目标对象实现的接口并设置。
 
 
setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));

public static Class[] getAllInterfacesForClass(Class clazz, @Nullable ClassLoader classLoader) {
   return toClassArray(getAllInterfacesForClassAsSet(clazz, classLoader));
}

// 此方法会查找clazz实现的所有接口及其父接口
public static Set> getAllInterfacesForClassAsSet(Class clazz, @Nullable ClassLoader classLoader) {
   Assert.notNull(clazz, "Class must not be null");
   // 如果clazz本身是一个接口，那么将返回它自己
   if (clazz.isInterface() && isVisible(clazz, classLoader)) {
      return Collections.singleton(clazz);
   }
   Set> interfaces = new LinkedHashSet<>();
   Class current = clazz;
   while (current != null) {
      Class[] ifcs = current.getInterfaces();
      for (Class ifc : ifcs) {
         if (isVisible(ifc, classLoader)) {
            interfaces.add(ifc);
         }
      }
      current = current.getSuperclass();
   }
   return interfaces;
}


public void setInterfaces(Class... interfaces) {
   Assert.notNull(interfaces, "Interfaces must not be null");
   this.interfaces.clear();
   for (Class ifc : interfaces) {
      addInterface(ifc);
   }
}

/**
 * Add a new proxied interface.
 * @param intf the additional interface to proxy
 */
public void addInterface(Class intf) {
   Assert.notNull(intf, "Interface must not be null");
   if (!intf.isInterface()) {
      throw new IllegalArgumentException("[" + intf.getName() + "] is not an interface");
   }
   if (!this.interfaces.contains(intf)) {
      this.interfaces.add(intf);
      adviceChanged();
   }
}


 
 
接下来，便是之前说过的根据情况使用jdk或者cglib创建代理对象。
 
 
原型
 
 
原型对象创建的过程与单例类似，不过多执行了一步拷贝操作。对于一个新的原型对象，需要拷贝一份配置信息，一份拦截器链以及一个TargetSource。当你使用原型模式时，你需要提供一个原型TargetSource以及原型Advisor，此时你的每一个代理对象都将是完全独立的。当然，如果你的这些对象是无状态的，那么效果也类似，唯一可能的问题便是并发争用。
 
 
private synchronized Object newPrototypeInstance() {
   // In the case of a prototype, we need to give the proxy
   // an independent instance of the configuration.
   // In this case, no proxy will have an instance of this object's configuration,
   // but will have an independent copy.
   if (logger.isTraceEnabled()) {
      logger.trace("Creating copy of prototype ProxyFactoryBean config: " + this);
   }

   ProxyCreatorSupport copy = new ProxyCreatorSupport(getAopProxyFactory());
   // The copy needs a fresh advisor chain, and a fresh TargetSource.
   TargetSource targetSource = freshTargetSource();
   copy.copyConfigurationFrom(this, targetSource, freshAdvisorChain());
   if (this.autodetectInterfaces && getProxiedInterfaces().length == 0 && !isProxyTargetClass()) {
      // Rely on AOP infrastructure to tell us what interfaces to proxy.
      Class targetClass = targetSource.getTargetClass();
      if (targetClass != null) {
         copy.setInterfaces(ClassUtils.getAllInterfacesForClass(targetClass, this.proxyClassLoader));
      }
   }
   copy.setFrozen(this.freezeProxy);

   if (logger.isTraceEnabled()) {
      logger.trace("Using ProxyCreatorSupport copy: " + copy);
   }
   return getProxy(copy.createAopProxy());
}

private List freshAdvisorChain() {
   Advisor[] advisors = getAdvisors();
   List freshAdvisors = new ArrayList<>(advisors.length);
   for (Advisor advisor : advisors) {
      // 如果是占位Advisor，此时真正获取其bean实例
      if (advisor instanceof PrototypePlaceholderAdvisor) {
         PrototypePlaceholderAdvisor pa = (PrototypePlaceholderAdvisor) advisor;
         if (logger.isDebugEnabled()) {
            logger.debug("Refreshing bean named '" + pa.getBeanName() + "'");
         }
         // Replace the placeholder with a fresh prototype instance resulting
         // from a getBean() lookup
         if (this.beanFactory == null) {
            throw new IllegalStateException("No BeanFactory available anymore (probably due to serialization) " +
                  "- cannot resolve prototype advisor '" + pa.getBeanName() + "'");
         }
         Object bean = this.beanFactory.getBean(pa.getBeanName());
         Advisor refreshedAdvisor = namedBeanToAdvisor(bean);
         freshAdvisors.add(refreshedAdvisor);
      }
      else {
         // Add the shared instance.
         freshAdvisors.add(advisor);
      }
   }
   return freshAdvisors;
}


 
 
其他
 
 
当创建完代理对象后，如果通过jdk代理创建，那么你可以将它转变为Advised对象，并且对拦截器链进行增删操作；或者你可以直接获取ProxyFactoryBean对象，并调用其方法增加接口或者修改拦截器链。此时，如果是singleton模式，那么之前缓存的代理对象将会被清除，下一次调用getObject()方法时将会获取一个新的代理对象，但是它们将会共享相同的拦截器链。如果修改的拦截器链，那么新旧两个代理对象还是会享有相同的配置；如果修改的是接口，那么新旧两个代理对象只有接口不同。如果是prototype模式，那么将对之前获取的代理对象毫无影响，只会在下一个调用getObject()方法时将会获取新代理对象。
 
 
关于ProxyFactoryBean的更多信息，请查看6.4. Using the ProxyFactoryBean to Create AOP Proxies。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(# 源码解析：AOP（2）)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • swagger访问路径
                        igotyback
swagger
                        
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    
                    
    • 
                    
  • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • 30天风格练习-DAY2
                        黄希夷

                        
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 开心
                        蒋泳频

                        
    从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
    1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
    
                    
    • 
                    
  • 本周第二次约练
                        2cfbdfe28a51

                        
    中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 今日联对0306
                        诗图佳得

                        
    自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
    
                    
    • 
                    
  • 每日一题——第八十九题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
    
                    
    • 
                    
  • 2022-07-08
                        保利学府里李楚怡1307022

                        
    ——保利碧桂园学府里——童梦奇趣【科学实验室】「7.9-7.10」✏玩出大智慧约99-144㎡二期全新升级力作
    
                    
    • 
                    
  • 每日一题——第八十一题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIPHPandroidlinux
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
                                    bozch
.net.net mvc
                                    
    在.net mvc5中，在执行某一操作的时候，出现了如下错误： 
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  
&
    
                                
    • 
                                
  • Java 对象大小的计算
                                    e200702084
java
                                    
                              Java对象的大小 
 
如何计算一个对象的大小呢？ 
 
 
   
    
                                
    • 
                                
  • Mybatis Spring
                                    171815164
mybatis
                                    
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    
                                
    • 
                                
  • JVM 不稳定参数
                                    g21121
jvm
                                    
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    
                                
    • 
                                
  • 用户自动登录网站
                                    永夜-极光
用户
                                    
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 
2.思路:将用户的信息保存为cookie 
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    
                                
    • 
                                
  • centos7 安装后失去win7的引导记录
                                    程序员是怎么炼成的
操作系统
                                    
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    
                                
    • 
                                
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
                                    aijuans
oracle
                                    
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio_V3.2发布了
                                    無為子
AOPoraclemysqljavaeeG4Studio
                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。 
  
访问G4Studio网站  
http://www.g4it.org      
G4Studio_V3.2版本变更日志 
功能新增 
(1).新增了系统右下角滑出提示窗口功能。 
(2).新增了文件资源的Zip压缩和解压缩
    
                                
    • 
                                
  • Oracle常用的单行函数应用技巧总结
                                    百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数
                                    
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 
一:字符函数: 
   .UPPER(字符串) 将字符串转为大写
   .LOWER (字符串) 将字符串转为小写 
   .INITCAP(字符串) 将首字母大写
   .LENGTH (字符串) 字符串的长度
   .REPLACE(字符串,'A','_') 将字符串字符A转换成_

    
                                
    • 
                                
  • Mockito异常测试实例
                                    bijian1013
java单元测试mockito
                                    
    Mockito异常测试实例： 
package com.bijian.study;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;

import org.mockito.
    
                                
    • 
                                
  • GA与量子恒道统计
                                    Bill_chen
JavaScript浏览器百度Google防火墙
                                    
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下： 
  
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    
                                
    • 
                                
  • 【Linux命令三】Top命令
                                    bit1129
linux命令
                                    
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： 
  
  
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total,   4 running, 198 sl
    
                                
    • 
                                
  • spring四种依赖注入方式
                                    白糖_
spring
                                    
       平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    
                                
    • 
                                
  • angular.injector
                                    boyitech
AngularJSAngularJS API
                                    
    angular.injector 
   描述:   创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.        使用方法:   angular.injector(modules, [strictDi])        参数详解:      Param Type Details   mod
    
                                
    • 
                                
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
                                    bylijinnan
Integer
                                    
    

public class PC {

	/**
	 * 题目：生产者-消费者。
	 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
	 */
	
	private static final Integer[] val=new Integer[10];
	private static
    
                                
    • 
                                
  • 使用Struts2.2.1配置
                                    Chen.H
apachespringWebxmlstruts
                                    
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar 
struts2-core-2.2.1.jar struts2-sp
    
                                
    • 
                                
  • [职业与教育]青春之歌
                                    comsci
教育
                                    
     
 
       每个人都有自己的青春之歌............但是我要说的却不是青春... 
 
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... 
 
  &nbs
    
                                
    • 
                                
  • oracle连接(join)中使用using关键字
                                    daizj
JOINoraclesqlusing
                                    
    在oracle连接(join)中使用using关键字 
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. 
Evaluate the following SQL statement: 
SELECT oi.order_id, product_id, order_date 
FRO
    
                                
    • 
                                
  • NIO示例
                                    daysinsun
nio
                                    
    NIO服务端代码： 
 

public class NIOServer {
	
	private Selector selector;

	
	public void startServer(int port) throws IOException {

		ServerSocketChannel serverChannel = ServerSocketChannel.open(
    
                                
    • 
                                
  • C语言学习homework1
                                    dcj3sjt126com
chomework
                                    
    0、 课堂练习做完 
1、使用sizeof计算出你所知道的所有的类型占用的空间。 
int x; 
sizeof(x); 
  
sizeof(int); 
  
# include <stdio.h>

int main(void)
{
	int x1;
	char x2;
	double x3;
	float x4;

	printf(&quo
    
                                
    • 
                                
  • select in order by , mysql排序
                                    dcj3sjt126com
mysql
                                    
    If i select like this: 
SELECT id FROM users WHERE id IN(3,4,8,1); 
This by default will select users in this order 
1,3,4,8, 
I would like to select them in the same order that i put IN() values so: 
    
                                
    • 
                                
  • 页面校验-新建项目
                                    fanxiaolong
页面校验
                                    
    $(document).ready(
	function() {
			var flag = true;
		$('#changeform').submit(function() {
			var projectScValNull = true;
			var s ="";
			var parent_id = $("#parent_id").v
    
                                
    • 
                                
  • Ehcache（02）——ehcache.xml简介
                                    234390216
ehcacheehcache.xml简介
                                    
    ehcache.xml简介 
  
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    
                                
    • 
                                
  • junit 4.11中三个新功能
                                    jackyrong
java
                                    
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 
 
 


import static org.junit.Assert.assertEquals;
 
import java.util.Arrays;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    
                                
    • 
                                
  • 国外程序员爱用苹果Mac电脑的10大理由
                                    php教程分享
windowsPHPunixMicrosoftperl
                                    
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 
1、Mac OS X 是基于 Unix 的 
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    
                                
    • 
                                
  • 位运算、异或的实际应用
                                    wenjinglian
位运算
                                    
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。 
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。 
      三． 位操作与空间压缩，针对筛素数进行空间压缩。 
   &n
    
                                
    • 
                                
  • weblogic部署项目出现的一些问题（持续补充中……）
                                    Everyday都不同
weblogic部署失败
                                    
    好吧，weblogic的问题确实…… 
  
问题一： 
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    
                                
    • 
                                
  • tomcat7性能调优（01）
                                    toknowme
tomcat7
                                    
      
    
Tomcat优化：   1、最大连接数最大线程等设置    
<Connector port="8082" protocol="HTTP/1.1" 
               useBodyEncodingForURI="t
    
                                
    • 
                                
  • PO VO DAO DTO BO TO概念与区别
                                    xp9802
javaDAO设计模式bean领域模型
                                    
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    
                                
    •