八五年的湘哥
八五年的湘哥

Spring AOP源码分析

目录

 

1、AOP是什么

2、AOP 的作用及其优势

3、AOP 的底层实现

3.1 JDK动态代理：

3.2 CGLIB动态代理

4、AOP相关概念

5、AOP运行流程图

6、AOP源码解析

6.1 源码解析须知

6.2 注册自动代理创建器

6.3 触发后置处理器

6.4 创建Proxy过程分析

6.5 代理回调增强

6.6 增强器执行

6.7 增强器执行顺序

7、源码总结

 

1、AOP是什么

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

直接看一个例子：

业务接口及其实现

public interface UserService {
   public void login(String name ,int length);
}
@Service
public class UserServiceImpl implements UserService {
   public void login(String name, int length) {
      System.out.println("-----我是一个接口,我的信息：用户-" + name + ", 长度-" +length+"-----") ;
   }
}

切面类

@Component
@Aspect
public class MyAspect {
​
   @Around("execution(* com.ydt.spring02.service.UserServiceImpl.*(..))")
   public void around(ProceedingJoinPoint point) throws Throwable {
      System.out.println("-----大哥，我来了-----");
      point.proceed();
      System.out.println("-----大哥，我走了-----");
   }

Spring核心配置



​
   
  

测试

@Test
public void test(){
   ApplicationContext context =
         new ClassPathXmlApplicationContext("applicationContext02.xml");
   System.out.println("-------------------------------------------------");
   UserService userService = context.getBean(UserService.class);
   userService.login("laohu", 18);
   System.out.println("-------------------------------------------------");
}

Spring AOP源码分析_第1张图片

2、AOP 的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强 优势：减少重复代码，提高开发效率，并且便于维护

3、AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

Spring AOP 的动态代理技术

JDK 代理 : 基于接口的动态代理技术 Cglib 代理：基于父类的动态代理技术

原理图：

Spring AOP源码分析_第2张图片

 

简单代码实现Jdk动态代理和Cglib动态代理

3.1 JDK动态代理：

目标类接口

public interface TargetInterface {
    public void method();
}
​

目标类

public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}
​

 

动态代理代码

        Target target = new Target();
        TargetInterface proxyObj = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("-------执行前增强------");
                        method.invoke(userService, null);
                        System.out.println("-------执行后增强------");
                        return null;
                    }
                }
        );
      

测试执行：

 //测试执行,当调用接口的任何方法时，代理对象的代码都无需修改
 proxy.method();

3.2 CGLIB动态代理

目标类

public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

动态代理代码

        Target userService = new Target(); //创建目标对象•
        Enhancer enhancer = new Enhancer(); //创建增强器•
        enhancer.setSuperclass(Target.class); //设置父类•
        enhancer.setCallback(new MethodInterceptor() { //设置回调•    @Override•
            public Object intercept(Object o, Method method, Object[] objects,
                                    MethodProxy methodProxy) throws Throwable {
                System.out.println("-------执行前增强------");
                Object invoke = method.invoke(userService, objects);
                System.out.println("-------执行后增强------");
                return invoke;
            }
        });
        Target proxy = (Target) enhancer.create(); //创建代理对象

测试执行：

 //测试执行,当调用接口的任何方法时，代理对象的代码都无需修改
 proxy.method();

4、AOP相关概念

  • Target（目标对象）：代理的目标对象

  • Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

  • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点

  • Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

  • Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知

  • Aspect（切面）：是切入点和通知（引介）的结合

  • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。

5、AOP运行流程图

Spring AOP源码分析_第3张图片

6、AOP源码解析

6.1 源码解析须知

  • 在使用ApplicationContext相关实现类加载bean的时候，会针对所有单例且非懒加载的bean，在构造ApplicationContext的时候就会创建好这些bean，而不会等到使用的时候才去创建。这也就是单例bean默认非懒加载的应用

  • 读者需要了解BeanPostProcessor的相关使用，所有实现BeanPostProcessor接口的类，在初始化bean的时候都会调用这些类的方法，一般用于在bean初始化前或后对bean做一些修改。而AOP的功能实现正式基于此，在bean初始化后创建针对该bean的proxy，然后返回给用户该proxy

  • 结合以上两点，被代理后的bean，实际在ApplicationContext构造完成之后就已经被创建完成，getBean()的操作直接从singletonObjects中获取即可

 

6.2 注册自动代理创建器

还记得上一节课我们在解析xml生成遍历文档树的时候，有几个标签不是默认解析的那个地方吗？

/************************************DefaultBeanDefinitionDocumentReader.java*******************************/
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
   if (delegate.isDefaultNamespace(root)) {
      NodeList nl = root.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         Node node = nl.item(i);
         if (node instanceof Element) {
            Element ele = (Element) node;
            if (delegate.isDefaultNamespace(ele)) {
               /*default namespace 涉及到的就四个标签
               * 、、 和 
               */
               parseDefaultElement(ele, delegate);
            }
            else {
               /*
               * 其他的属于 custom（拓展）如我们经常会使用到的
               * 、、、等
               */
               delegate.parseCustomElement(ele);
            }
         }
      }
   }
   else {
      delegate.parseCustomElement(root);
   }
}

但凡注解都有对应的解析器，以用来解析该注解的行为。而且所有的解析器父类为： NamespaceHandlerSupport全局搜索之后可发现(其实你也可以通过调用链来查看)

Spring AOP源码分析_第4张图片

//org.springframework.aop.config.AopNamespaceHandler类中有对应的解析行为，代码如下：
public class AopNamespaceHandler extends NamespaceHandlerSupport {
    @Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
         //看这里---AOP自动代理Bean定义对象解析器注册
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
 
        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}

看看AspectJAutoProxyBeanDefinitionParser这个解析器是一个啥玩意，他实现了BeanDefinitionParser的parse方法

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {
​
    @Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        //开始注册切面注解自动代理创建器
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        extendBeanDefinition(element, parserContext);
        return null;
    }
    //..............................................................
}

6.3 触发后置处理器

通过以上的代码分析，可知，AspectJAutoProxyBeanDefinitionParser主要的功能就是将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中，把bean交给Spring去托管。AnnotationAwareAspectJAutoProxyCreator的功能我们大胆猜测一下：应该也就是生成对象的代理类的相关功能，这个我们接下来再看。

前面我们说了AOP是基于BeanPostProcessor后置处理器来实现的，通过查看AnnotationAwareAspectJAutoProxyCreator的类层次结构，可知，其实现了BeanPostProcessor接口，实现类为AbstractAutoProxyCreator（这里就是模板模式） :

Spring AOP源码分析_第5张图片

AbstractAutoProxyCreator主要方法

    
    /*********************************AbstractAutoProxyCreator.java************************/
    //前置方法啥也不干，直接返回
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        return bean;
    }
 
    // 主要看这个方法，在bean初始化之后对生产出的bean进行包装
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        //对象实例化、属性注入完成后
        // 在initializeBean.applyBeanPostProcessorsAfterInitialization方法中触发
        //PS:AnnotationAwareAspectJAutoProxyCreator他爹实现的后置处理器（看下面调用链截图）
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.contains(cacheKey)) {
                 //生成动态代理对象并且包装起来
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

Spring AOP源码分析_第6张图片

总结：

1）通过AspectJAutoProxyBeanDefinitionParser类将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中

2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy--->wrapIfNecessary()

6.4 创建Proxy过程分析

6.4.1 进入AOP拦截器

/*********************************AbstractAutoProxyCreator.java************************/
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
   //..........................................
   // Create proxy if we have advice.
   // 意思就是如果该类有advice（增强,还有可能有多个）则创建proxy，这个里面还对所有增强进行了排序
   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
   if (specificInterceptors != DO_NOT_PROXY) {
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
      // 将普通的Bean替换成代理Bean
      Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
   }

   this.advisedBeans.put(cacheKey, Boolean.FALSE);
   return bean;
}

6.4.2 创建代理工厂

/*********************************AbstractAutoProxyCreator.java************************/
protected Object createProxy(Class beanClass, @Nullable String beanName,
			@Nullable Object[] specificInterceptors, TargetSource targetSource) {
		//保存代理类真实的类型，代理对象执行反射调用的时候还得用
		//public static final String ORIGINAL_TARGET_CLASS_ATTRIBUTE =
		//			Conventions.getQualifiedAttributeName(AutoProxyUtils.class, "originalTargetClass");
		if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
			AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
		}
		// 1.创建ProxyFactory，proxy对象的生产主要就是在ProxyFactory做的（FactoryBean）
		ProxyFactory proxyFactory = new ProxyFactory();
		proxyFactory.copyFrom(this);

		//判断有没有设置proxy-target-class="true" ,默认为false
		if (!proxyFactory.isProxyTargetClass()) {
			//配置了还不行，还得判断该Bean是否包含接口
			//如果不包含，将来要使用CGLIB方式
			//如果包含，还是走JDK方式，并且将接口设置到ProxyFactory代理工厂
			if (shouldProxyTargetClass(beanClass, beanName)) {
				proxyFactory.setProxyTargetClass(true);
			}
			else {
				evaluateProxyInterfaces(beanClass, proxyFactory);
			}
		}
		// 2.将当前bean适合的advice，重新封装下，封装为Advisor类，然后添加到ProxyFactory中
		Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
		proxyFactory.addAdvisors(advisors);
		proxyFactory.setTargetSource(targetSource);
		customizeProxyFactory(proxyFactory);
		//冻结代理工厂，此时不允许其他线程来对该对象再次代理
		proxyFactory.setFrozen(this.freezeProxy);
		if (advisorsPreFiltered()) {
			proxyFactory.setPreFiltered(true);
		}
		// 3.调用getProxy获取bean对应的proxy（命名怎么跟getBean一个德行?）
		return proxyFactory.getProxy(getProxyClassLoader());
	}

6.4.3 创建何种类型的Proxy

    /*********************************ProxyFactory.java************************/
	public Object getProxy(@Nullable ClassLoader classLoader) {
		//这里有两个方法
		//createAopProxy()-->得到代理工具类对象：JdkDynamicAopProxy or ObjenesisCglibAopProxy
		//getProxy() --->得到原始bean的代理对象
		return createAopProxy().getProxy(classLoader);
	}
 	
    /*********************************ProxyCreatorSupport.java************************/
    // createAopProxy()方法就是决定究竟创建何种类型的proxy
	protected final synchronized AopProxy createAopProxy() {
		//生成代理对象工具类的计数，避免生成多个
		if (!this.active) {
			activate();
		}
		//获取AOP代理工厂并且创建AOP代理工具类（工厂方法模式）
		return getAopProxyFactory().createAopProxy(this);
	}
 
 	/*********************************DefaultAopProxyFactory.java************************/
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		//isOptimize() :是否使用优化的代理策略(ThreadLocal线程变量 线程隔离)，默认就是false，可以通过expose-proxy="true"改变
		//isProxyTargetClass()：是否直接代理目标类以及任何接口。默认false，可以通过proxy-target-class="true"改变
		//hasNoUserSuppliedProxyInterfaces :确定提供的切面类是否只有SpringProxy指定的接口，或者根本没有指定代理接口
		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
			Class targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				//JDK分支
				return new JdkDynamicAopProxy(config);
			}
			//CGLIB分支
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			//默认走JDK分支
			return new JdkDynamicAopProxy(config);
		}
	}

6.4.4 生成代理对象

/*********************************JdkDynamicAopProxy.java************************/
public Object getProxy(@Nullable ClassLoader classLoader) {
		if (logger.isTraceEnabled()) {
			logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
		}
		//得到目标类接口，SpringProxy,Advised,DecoratingProxy,都要进行反向代理
		Class[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
		//排除equals,hashCode等基类方法的增强，如果有这种增强，直接结束
		findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
		//进入JDK动态代理方法,这个就不说了，你不可再改了
		return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
	}
/*********************************CglibAopProxy.java************************/
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;
      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.
      validateClassIfNecessary(proxySuperClass, classLoader);

      // CGLIB增强器
      Enhancer enhancer = createEnhancer();
      if (classLoader != null) {
         //设置类加载器
         enhancer.setClassLoader(classLoader);
         if (classLoader instanceof SmartClassLoader &&
               ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
            enhancer.setUseCache(false);
         }
      }
      //设置父类
      enhancer.setSuperclass(proxySuperClass);
      //需要设置SpringProxy,Advised增强接口，跟JDK动态代理一样，用于反射
      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);

      // 生成代理类和代理对象，这个就跟之前代理模式一样了
      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);
   }
}

6.5 代理回调增强

	/*********************************JdkDynamicAopProxy.java************************/
	/**
	 * 重写了InvocationHandler的invoke回调方法，在此处增强
	 */
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object oldProxy = null;
		boolean setProxyContext = false;
		//目标源
		TargetSource targetSource = this.advised.targetSource;
		Object target = null;

		try {
			// 以下的几个判断，判断目标对象有没有实现Object类的equals、hashCode等Object的方法重写
			// 如果没有，不进行增强，直接调用Object里面对应的方法
			if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
				// The target does not implement the equals(Object) method itself.
				return equals(args[0]);
			}
			else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
				// The target does not implement the hashCode() method itself.
				return hashCode();
			}
			else if (method.getDeclaringClass() == DecoratingProxy.class) {
				// There is only getDecoratedClass() declared -> dispatch to proxy config.
				return AopProxyUtils.ultimateTargetClass(this.advised);
			}
			else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
					method.getDeclaringClass().isAssignableFrom(Advised.class)) {
				// Service invocations on ProxyConfig with the proxy config...
				return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
			}

			Object retVal;
			//如果当前通知暴露了代理，则将当前执行对象使用currentProxy()方法变为当前对象代理
			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);

			// Get the interception chain for this method.
			//获取当前方法配置的拦截方法链（有可能多个增强），通过适配器获取适handler（多个Interceptor）
			List chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

			// Check whether we have any advice. If we don't, we can fallback on direct
			// reflective invocation of the target, and avoid creating a MethodInvocation.
			if (chain.isEmpty()) {
				// 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.
				// 如果拦截器为空，那么直接调用target的对应方法，并获取方法返回值.
				Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
				retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
			}
			else {
				// 为目标对象创建方法回调对象，需要在调用通知之后才调用目标对象的方法
				MethodInvocation invocation =
						new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
				// 依次调用拦截器链，这是一个递归实现.
				retVal = invocation.proceed();
			}

			// 方法有返回值，则将代理对象作为方法返回.
			Class returnType = method.getReturnType();
			if (retVal != null && retVal == target &&
					returnType != Object.class && returnType.isInstance(proxy) &&
					!RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
				//如果目标在另一个返回的对象中设置对自身的引用，我们将无法帮助A
				retVal = proxy;
			}
			else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
				throw new AopInvocationException(
						"Null return value from advice does not match primitive return type for: " + method);
			}
			return retVal;
		}
		finally {
			if (target != null && !targetSource.isStatic()) {
				// 释放目标对象
				targetSource.releaseTarget(target);
			}
			if (setProxyContext) {
				//将代理对象工具类对象设置到当前上下文,下次继续用
				AopContext.setCurrentProxy(oldProxy);
			}
		}
	} 
  
适配器和handler所在包目录：
 
  
Spring AOP源码分析_第7张图片
 
  
CGLIB的回调增强差不太多！
 
  
/*********************************CglibAopProxy.java************************/
private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

   private final AdvisedSupport advised;

   public DynamicAdvisedInterceptor(AdvisedSupport advised) {
      this.advised = advised;
   }

   @Override
   @Nullable
   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);
         }
      }
   } 
  
6.6 增强器执行
 
  
/*********************************ReflectiveMethodInvocation.java************************/
public Object proceed() throws Throwable {
		// We start with an index of -1 and increment early.
		if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
			//从索引为-1的拦截器开始调用，并按序递增
			//若拦截器链中的拦截器迭代调用完毕，则就是调用target的函数
			//这个函数是通过反射机制完成的，具体实现在AopUtils.invokeJoinpointUsingReflection方法中
			return invokeJoinpoint();
		}

		//获取配置的Advice
		Object interceptorOrInterceptionAdvice =
				this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
		//通知是动态匹配方法拦截器类型
		if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
			// Evaluate dynamic method matcher here: static part will already have
			// been evaluated and found to match.
			//动态匹配方法拦截器 .
			InterceptorAndDynamicMethodMatcher dm =
					(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
			Class targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
			if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
				//调用拦截器的执行方法，拦截器执行拦截逻辑后继续调用目标方法的proceed()方法
				return dm.interceptor.invoke(this);
			}
			else {
				// Dynamic matching failed.
				// Skip this interceptor and invoke the next in the chain.
				//切面类对象方法和目标类没匹配上，跳过这个拦截器并调用链中的下一个拦截器（递归调用）
				return proceed();
			}
		}
		else {
			// It's an interceptor, so we just invoke it: The pointcut will have
			// been evaluated statically before this object was constructed.
			//如果是一个interceptor，直接调用这个interceptor对应的方法，
			// 进入各种通知过滤器:*AdviceInterceptor和事务过滤器TransactionInterceptor（适配器模式）
			return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
		}
	}
 
  
依次遍历拦截器链的每个元素，然后调用其实现，将真正调用工作委托给各个增强器
 
  
6.7 增强器执行顺序
 
  
我们知道增强其执行顺序是这样的：
 
  
Spring AOP源码分析_第8张图片
 
  
现在我们来进行源码调试看看：
 
  
纵观以上过程可知：实际就是为bean创建一个proxy，JDK Proxy或者CGLIB Proxy，然后在调用bean的方法时，会通过proxy来反射调用bean方法，通过执行代理回调来进行功能增强！
 
  
20210122173616905.png
 
  
1：默认 ExposeInvocationInterceptor ​ 2：异常通知 AspectJAfterThrowingAdvice ​ 3：返回通知 AspectJAfterReturningAdvice->AfterReturningAdviceInterceptor ​ 4：后置通知 AspectJAfterAdvice ​ 5：环绕通知 AspectJAroundAdvice ​ 6：前置通知 AspectJMethodBeforeAdvice->MethodBeforeAdviceInterceptor
 
  
invoke调用顺序为： 1-2-3-4-5（joinPoint.proceed()之前的部分先执行，通过proceed继续递归）-6
 
  
那么invoke方法里面各个对应的通知方法执行顺序为： 5的前一部分（因为在invoke方法中已经先执行）–6（递归的最后一层）–目标方法（递归结束执行目标方法）–返回到5的后一部分–返回到4（finally块必会执行）–返回到3（有异常逃过不执行）–返回到2（try块里有异常才执行）–返回到1默认拦截器方法
 
  
7、源码总结
 
  
重点过程可分为：
 
  
1）通过AspectJAutoProxyBeanDefinitionParser类将AnnotationAwareAspectJAutoProxyCreator注册到Spring容器中
 
  
2）AnnotationAwareAspectJAutoProxyCreator类的postProcessAfterInitialization()方法将所有有advice的bean重新包装成proxy
 
  
3）调用bean方法时通过proxy来调用，proxy依次调用增强器的相关方法，来实现方法切入
 
  
 
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(SSM&开源组件,java,spring,aop)

        

            

                
    
                    
  • 刷题前必学！栈与队列！用JavaScript学数据结构与算法
                        

                        
    ‍JavaScript数据结构与算法-HowieCong务必要熟悉JavaScript使用再来学！一、数组增删操作在了解栈和队列前，明确数组中的增删操作具有什么样的特性、对应的方法有哪些：灵活增删的数组数组增加元素的三种方法：unshift方法，添加元素到数组的头部constarr=[1,2]arr.unshift(0)//[0,1,2]push方法，添加元素到数组的尾部constarr=[1,2
    
                    
    • 
                    
  • Android OkHttp使用和源码详解
                        2401_85729264
androidokhttp
                        
    本文使用的OkHttp的版本为3.14.2,不是不会接入高版本，主要是4.0.x版本已经全部由java替换到了Kotlin，Kotlin不太熟怕理解错了，误导人民群众。dependencies{//本文使用implementation‘com.squareup.okio:okio:1.15.0’implementation‘com.squareup.okhttp3:okhttp:3.14.2’//
    
                    
    • 
                    
  • Java基础入门day55
                        zpz2001
javahive开发语言
                        
    day55过滤器简介过滤器filter，是处于客户端与服务器端目标资源之间的一道过滤技术技术作用执行地位在servlet之前，客户发送请求时，会先经过Filter，再到达目标Servlet中。相应时，会根据执行流程再次反向执行Filter可以解决多个Servlet共性代码的冗余问题编写新增一个类，实现Filter接口编写其生命周期方法再doFilter当中实现过滤方法packagecom.saas
    
                    
    • 
                    
  • Spring Cloud 与 Dubbo 的区别及选择指南
                        星辰@Sea
系统架构Javaspringclouddubbospring云原生
                        
    目录引言定义SpringCloudDubbo底层技术SpringCloudDubbo用途SpringCloudDubbo使用场景SpringCloudDubbo如何选择业务需求技术栈社区支持扩展性总结引言随着微服务架构的流行，SpringCloud和Dubbo成为了构建分布式系统的两大热门框架。两者虽然都旨在简化微服务的开发与管理，但它们在设计理念、实现方式、应用场景等方面存在着显著差异。本文将从
    
                    
    • 
                    
  • Java基础入门-Day1
                        weixin_45795542
JAVAJAVA基础入门-Day1
                        
    Java基础入门-Day1JAVA开发入门特点分类Java字节执行方式JDK的使用Java垃圾回收机制Java编译JAVA开发入门Java是一种高级计算机语言。他是由Sun公司(已被Oracle公司于2009年4月20日收购)于1995年5月推出的一种可以编写跨平台应用软件丶完全面向对象的程序设计语言。特点资源免费跨平台健壮，安全高性能简单面向对象动态性多线程分类Java针对不同的开发市场，Sun
    
                    
    • 
                    
  • Rollup 实践：从入门到精通
                        小亮同学丶
构建工具和模块打包javascript前端webpack
                        
    Rollup是一个高效的JavaScript模块打包器，特别适用于库和应用程序的打包。本文将深入探讨Rollup的实践方法，包括配置示例、性能优化策略以及不同场景下的最佳实践。基本配置首先，我们来看一个简单的Rollup配置示例：importresolvefrom'@rollup/plugin-node-resolve';importcommonjsfrom'@rollup/plugin-comm
    
                    
    • 
                    
  • 【思维导图】并发编程
                        rainbow--
java并发编程
                        
    并发和并行的区别并发是指多个任务交替执行。并行是指多个任务同时被执行。线程与进程的区别1、进程包含线程。2、线程之间可以共享数据，比如说java线程之间共享堆内存和方法区里的数据。而进程之间是独立的，默认情况下是不共享数据的。3、线程上下文切换开销小，而进程上下文切换开销大。（当线程状态改变时，就会出现线程上下文切换。线程上下文切换涉及到用户态与内核态的转变，因此开销较大。）java线程与操作系统
    
                    
    • 
                    
  • Mybatis（Day 18）
                        m0_73629914
数据库
                        
    数据持久化是将内存中的数据模型转换为存储模型，以及将存储模型转换为内存中数据模型的统称。MyBatis支持定制化SQL、存储过程以及高级映射，可以在实体类和SQL语句之间建立映射关系，是一种半自动化的ORM实现。ORM（ObjectRelationalMapping，对象关系映射）是一种数据持久化技术，它在对象模型和关系型数据库之间建立起对应关系，并且提供了一种机制，通过JavaBean对象去操作
    
                    
    • 
                    
  • Java基础（Day11)
                        m0_73629914
java开发语言
                        
    一、反射1.反射有对象必须先有类，static修饰类的属性与方法在java中存储了类的内容，这个内容也应该是一个对象java中用到的每一个类都会有一个内存，这每一块内容都是一个对象这些对象用于记录这些类中声明了哪些方法和构造方法java将这些类抽象为一个Class类类的类对象中存储了类定义的内容---属性方法构造方法一开始可以不知道是哪一个类（类对象），可以通过传入参数获取---框架思想反射机制相
    
                    
    • 
                    
  • 【2024年华为OD机试】(B卷,100分)- 热点网站统计（Java & JS & Python&C/C++）
                        妄北y
华为odjavajavascript矩阵c语言python
                        
    一、问题描述题目描述企业路由器的统计页面需要动态统计公司访问最多的网页URL的TopN。设计一个算法，能够高效动态统计TopN的页面。输入描述每一行都是一个URL或一个数字：如果是URL，代表一段时间内的网页访问。如果是数字N，代表本次需要输出的TopN个URL。输入约束：总访问网页数量小于5000个，单网页访问次数小于65535次。网页URL仅由字母、数字和点分隔符组成，且长度小于等于127字节
    
                    
    • 
                    
  • 初识Node.js：入门指南与核心特性解析
                        Singe.Chen
JavaScriptnode.js
                        
    引言Node.js是一种基于ChromeV8引擎构建的JavaScript运行环境，它允许开发者使用JavaScript进行服务器端编程。自2009年发布以来，Node.js因其高效的性能和广泛的应用而迅速成为后端开发的热门选择。本文将介绍Node.js的基本概念、安装和使用方法，并探讨其核心特性如事件驱动和非阻塞I/O，提供一些简单的代码示例，帮助初学者快速入门。Node.js的基本概念Node
    
                    
    • 
                    
  • Java基础知识总结（三十一）--API--- java.lang.System
                        a18007931080
java开发语言
                        
    属性和行为都是静态的。longcurrentTimeMillis();//返回当前时间毫秒值exit();//退出虚拟机PropertiesgetProperties();//获取当前系统的属性信息Propertiesprop=System.getProperties();//获取系统的属性信息，并将这些信息存储到Properties集合中。System.setProperty("myname",
    
                    
    • 
                    
  • Java基础知识总结（二十二）--List接口
                        a18007931080
javalist开发语言
                        
    List本身是Collection接口的子接口，具备了Collection的所有方法。现在学习List体系特有的共性方法，查阅方法发现List的特有方法都有索引，这是该集合最大的特点。List：有序(元素存入集合的顺序和取出的顺序一致)，元素都有索引。元素可以重复。|--ArrayList：底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快。|--Link
    
                    
    • 
                    
  • 【Java】已解决：`java.lang.NoClassDefFoundError`
                        屿小夏
java开发语言
                        
    个人简介：某不知名博主，致力于全栈领域的优质博客分享|用最优质的内容带来最舒适的阅读体验！文末获取免费IT学习资料！文末获取更多信息精彩专栏推荐订阅收藏专栏系列直达链接相关介绍书籍分享点我跳转书籍作为获取知识的重要途径，对于IT从业者来说更是不可或缺的资源。不定期更新IT图书，并在评论区抽取随机粉丝，书籍免费包邮到家AI前沿点我跳转探讨人工智能技术领域的最新发展和创新，涵盖机器学习、深度学习、自然
    
                    
    • 
                    
  • 【Java】已解决java.lang.NoSuchMethodException异常
                        屿小夏
javapython开发语言
                        
    个人简介：某不知名博主，致力于全栈领域的优质博客分享|用最优质的内容带来最舒适的阅读体验！文末获取免费IT学习资料！文末获取更多信息精彩专栏推荐订阅收藏专栏系列直达链接相关介绍书籍分享点我跳转书籍作为获取知识的重要途径，对于IT从业者来说更是不可或缺的资源。不定期更新IT图书，并在评论区抽取随机粉丝，书籍免费包邮到家AI前沿点我跳转探讨人工智能技术领域的最新发展和创新，涵盖机器学习、深度学习、自然
    
                    
    • 
                    
  • 07【Java核心API-01】
                        緑水長流*z
#《JavaSE系列》javajavaseJava基础String常量池
                        
    上一篇：06【接口、多态】下一篇：08【Java核心API-02】目录：【JavaSE零基础系列教程目录】文章目录07【Java核心API-01】一、API概述1.1API概述1.2Java常用包介绍1.3java.lang包1.4Java开发手册二、Scanner类2.1Scanner简介2.2Scanner类的使用2.2.1导包2.2.2创建对象2.2.3常用方法2.2.4使用示例2.2.5n
    
                    
    • 
                    
  • nacos配置中心
                        yyueshen
javaspringbootspringcloudCloudAlibabanacos微服务
                        
    首先配置maven，添加spring-cloud-starter-alibaba-nacos-configorg.springframework.bootspring-boot-starter-webcom.alibaba.cloudspring-cloud-starter-alibaba-nacos-configcom.alibaba.cloudspring-cloud-alibaba-depe
    
                    
    • 
                    
  • python创建excel图表_Python:使用图表创建Excel工作表
                        weixin_39546312
python创建excel图表
                        
    它有点复杂(和/或邪恶)，但类似的东西可以跨平台(包括在Linux下)使用JPype来包装SmartXLSExcelJava库。此示例使用SmartXLS中的简单图表创建(在Charts/ChartSample.class中)示例。#!/usr/bin/envpythonimportosimportos.pathimportjpype#orwhereveryourjavaisinstalledos
    
                    
    • 
                    
  • 主流编程语言的优劣分析及学习建议
                        我的青春不太冷
学习java开发语言android经验分享笔记
                        
    不同语言的特性主流编程语言的优劣分析及学习建议1.Python优点缺点学习建议适用于哪些人？2.JavaScript优点缺点学习建议适用于哪些人？3.Java优点缺点学习建议适用于哪些人？4.C++优点缺点学习建议适用于哪些人？5.Swift优点缺点学习建议适用于哪些人？结论主流编程语言的优劣分析及学习建议对于年轻人或者即将开始编程学习的人来说，选择一门合适的编程语言至关重要。不同的编程语言有各自
    
                    
    • 
                    
  • java excel 转 图片_Java 将Excel转为图片、html、XPS、XML、CSV
                        甜甜呀嘿
javaexcel转图片
                        
    通过文档格式转换，可满足不同办公场合对文档操作的需求。本文将介绍转换Excel文档为其他常见文档格式的方法。通过文中的方法，可支持将Excel转换为包括PDF、图片、html、XPS、XML、CSV、PCL、ODS、PostScript、以及OfficeExcel不同版本，如，version97-2003，version2007，version2010，version2013，version201
    
                    
    • 
                    
  • java 字节文件类型_Java根据字节数据判断文件类型
                        weixin_39795284
java字节文件类型
                        
    通常，在WEB系统中，上传文件时都需要做文件的类型校验，大致有如下几种方法：1.通过后缀名，如exe,jpg,bmp,rar,zip等等。2.通过读取文件，获取文件的Content-type来判断。3.通过读取文件流，根据文件流中特定的一些字节标识来区分不同类型的文件。4.若是图片，则通过缩放来判断，可以缩放的为图片，不可以的则不是。然而，在安全性较高的业务场景中，1，2两种方法的校验会被轻易绕过
    
                    
    • 
                    
  • Java 代码实现pdf转word文件 | 无损转换完整代码教程
                        泰山AI
Java高级技术java开发语言poipdf
                        
    前言最近有个需求，我自己有个pdf想转word去修改，百度很多工具都是注册账号前一两次免费，后面就要收费，由于，本人之前的也转换过好几次，免费额度都用完了。百度了半天也没找到一个免费，于是决定自己用代码实现转换，觉得应该不难，后来，调试1-2个小时的代码终于实现了！pdf转word实现思路代码实现主要依赖两个第三方jar包，一个是apache-poi，一个是aspose-pdf。apache-po
    
                    
    • 
                    
  • 10.1、LNMT架构
                        weixin_30832405
java数据库运维
                        
    Java环境安装包下载路径：https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.htmlTomcat安装包下载路径：https://tomcat.apache.org/download-90.cgijpress软件下载：http://jpress.io/downloadJava环境安装上传j
    
                    
    • 
                    
  • 我的开发技术栈
                        pigdreams
软件设计师androidjava
                        
    前言软件开发需要涉及的知识点非常多，要完成一个项目更是需要各方面的知识配合，从事Android开发这些年，从Java知识到Android知识，接触到的技术点很多，但是缺少一个对于自身的全方面总结，现在终于把自己所有掌握到的技术点进行一次梳理。目的在于知晓自己的不足，从而针对性地弥补不足。Java技术栈Android技术栈需要成长的知识点序号知识点1LSP-里氏替换原则2桥接模式（BridgePat
    
                    
    • 
                    
  • Ubuntu上如何优雅下载huggingface上某个gguf模型文件
                        晨欣
ubuntulinux运维
                        
    OS:Ubuntu22.04LTS需求：下载GorillaOpenfunctionsV2Q2GGUF模型到本地https://huggingface.co/gorilla-llm/gorilla-openfunctions-v2-gguf/blob/main/gorilla-openfunctions-v2-q2_K.gguf方法：使用wget命令wgethttps://huggingface.c
    
                    
    • 
                    
  • 分支限界法 01背包 java_分支限界法解决01背包问题
                        weixin_39530509
分支限界法01背包java
                        
    分支限界法和之前讲的回溯法有一点相似，两者都是在问题的解的空间上搜索问题的解。但是两者还是有一些区别的，回溯法是求解在解的空间中的满足的所有解，分支限界法则是求解一个最大解或最小解。这样，两者在解这一方面还是有一些不同的。之前回溯法讲了N后问题，这个问题也是对于这有多个解，但是今天讲的01背包问题是只有一个解的。下面就讲讲分支限界法的基本思想。分支限界法常以广度优先或以最小消耗(最大效益)优先的方
    
                    
    • 
                    
  • SpringBoot在Kubernetes上部署及其扩展实践
                        AI天才研究院
Python实战自然语言处理人工智能语言模型编程实践开发语言架构设计
                        
    作者：禅与计算机程序设计艺术1.简介SpringBoot是微服务开发的一个重要工具。它可以快速、轻松地创建一个独立运行的应用，同时还有一个特性就是它可以让开发者更关注业务逻辑而不是配置。SpringCloud生态圈则提供了许多服务发现、熔断器等功能组件，可以帮助我们实现微服务之间的通信、监控、路由等功能。但是，如果想要把SpringBoot部署到Kubernetes集群上，那么就需要做一些额外的工
    
                    
    • 
                    
  • 类加载的过程
                        码农小旋风
后端
                        
    类加载的过程类加载过程包括5个阶段：加载、验证、准备、解析和初始化。加载加载的过程“加载”是“类加载”过程的一个阶段，不能混淆这两个名词。在加载阶段，虚拟机需要完成3件事：通过类的全限定名获取该类的二进制字节流。将二进制字节流所代表的静态结构转化为方法区的运行时数据结构。在内存中创建一个代表该类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。获取二进制字节流对于Clas
    
                    
    • 
                    
  • JVM 性能调优
                        码农小旋风
后端
                        
    JVM性能调优在高性能硬件上部署程序，目前主要有两种方式：通过64位JDK来使用大内存；使用若干个32位虚拟机建立逻辑集群来利用硬件资源。使用64位JDK管理大内存堆内存变大后，虽然垃圾收集的频率减少了，但每次垃圾回收的时间变长。如果堆内存为14G，那么每次FullGC将长达数十秒。如果FullGC频繁发生，那么对于一个网站来说是无法忍受的。对于用户交互性强、对停顿时间敏感的系统，可以给Java虚
    
                    
    • 
                    
  • java development kit - 11 - jdk下载安装、环境变量设置
                        「已注销」
java
                        
    目录JavaSE(StandardEdition,标准版)-11jdk下载jdk-11.0.6_windows安装设置环境变量JavaSE(StandardEdition,标准版)-11jdk下载如果懒得去官网下载可以直接在下面这个下载，然后跳过这一步，这个链接提供的是jdk11.0.6的Windows版本。官网其实也很坑，下载页面有时显示不出来，然后下载可能要注册登录。百度云--jdk-11.0
    
                    
    • 
                                
  • 遍历dom 并且存储（将每一层的DOM元素存在数组中）
                                    换个号韩国红果果
JavaScripthtml
                                    
    数组从0开始！！ 
 


var a=[],i=0;
for(var j=0;j<30;j++){
		a[j]=[];//数组里套数组，且第i层存储在第a[i]中
	}

function walkDOM(n){
	
			do{
			if(n.nodeType!==3)//筛选去除#text类型

			a[i].push(n);
			
			//con
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列(9)-总结和代码分享
                                    白糖_
JQuery Mobile
                                    
    目录导航 
  
经过一个多月的边学习边练手，学会了Android基于Web开发的毛皮，其实开发过程中用Android原生API不是很多，更多的是HTML/Javascript/Css。 
  
个人觉得基于WebView的Jquery Mobile开发有以下优点： 
1、对于刚从Java Web转型过来的同学非常适合，只要懂得HTML开发就可以上手做事。 
2、jquerym
    
                                
    • 
                                
  • impala参考资料
                                    dayutianfei
impala
                                    
    记录一些有用的Impala资料 
  
1. 入门资料 
>>官网翻译： 
    http://my.oschina.net/weiqingbin/blog?catalog=423691 
  
2. 实用进阶 
>>代码&架构分析： 
    Impala/Hive现状分析与前景展望：http
    
                                
    • 
                                
  • JAVA 静态变量与非静态变量初始化顺序之新解
                                    周凡杨
java静态非静态顺序
                                    
    今天和同事争论一问题，关于静态变量与非静态变量的初始化顺序，谁先谁后，最终想整理出来！测试代码： 
import java.util.Map;

public class T {

	public static T t = new T();
	private Map map = new HashMap();
	public T(){
		System.out.println(&quo
    
                                
    • 
                                
  • 跳出iframe返回外层页面
                                    g21121
iframe
                                    
    在web开发过程中难免要用到iframe，但当连接超时或跳转到公共页面时就会出现超时页面显示在iframe中，这时我们就需要跳出这个iframe到达一个公共页面去。 
首先跳转到一个中间页，这个页面用于判断是否在iframe中，在页面加载的过程中调用如下代码： 
<script type="text/javascript">
//<!--
function
    
                                
    • 
                                
  • JAVA多线程监听JMS、MQ队列
                                    510888780
java多线程
                                    
    背景：消息队列中有非常多的消息需要处理，并且监听器onMessage（）方法中的业务逻辑也相对比较复杂，为了加快队列消息的读取、处理速度。可以通过加快读取速度和加快处理速度来考虑。因此从这两个方面都使用多线程来处理。对于消息处理的业务处理逻辑用线程池来做。对于加快消息监听读取速度可以使用1.使用多个监听器监听一个队列；2.使用一个监听器开启多线程监听。 
对于上面提到的方法2使用一个监听器开启多线
    
                                
    • 
                                
  • 第一个SpringMvc例子
                                    布衣凌宇
spring mvc
                                    
    第一步：导入需要的包； 
第二步：配置web.xml文件 
 
<?xml version="1.0" encoding="UTF-8"?> 
<web-app version="2.5" 
 xmlns="http://java.sun.com/xml/ns/javaee" 
 xmlns:xsi=
    
                                
    • 
                                
  • 我的spring学习笔记15-容器扩展点之PropertyOverrideConfigurer
                                    aijuans
Spring3
                                    
    PropertyOverrideConfigurer类似于PropertyPlaceholderConfigurer，但是与后者相比，前者对于bean属性可以有缺省值或者根本没有值。也就是说如果properties文件中没有某个bean属性的内容，那么将使用上下文（配置的xml文件）中相应定义的值。如果properties文件中有bean属性的内容，那么就用properties文件中的值来代替上下
    
                                
    • 
                                
  • 通过XSD验证XML
                                    antlove
xmlschemaxsdvalidationSchemaFactory
                                    
    1. XmlValidation.java 
package xml.validation;

import java.io.InputStream;

import javax.xml.XMLConstants;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schem
    
                                
    • 
                                
  • 文本流与字符集
                                    百合不是茶
PrintWrite()的使用字符集名字 别名获取
                                    
    文本数据的输入输出; 
          输入;数据流,缓冲流 
  
      输出;介绍向文本打印格式化的输出PrintWrite(); 
  
package 文本流;

import java.io.FileNotFound
    
                                
    • 
                                
  • ibatis模糊查询sqlmap-mapping-**.xml配置
                                    bijian1013
ibatis
                                    
            正常我们写ibatis的sqlmap-mapping-*.xml文件时，传入的参数都用##标识，如下所示： 
<resultMap id="personInfo" class="com.bijian.study.dto.PersonDTO">
	<res
    
                                
    • 
                                
  • java jvm常用命令工具——jdb命令(The Java Debugger)
                                    bijian1013
javajvmjdb
                                    
            用来对core文件和正在运行的Java进程进行实时地调试，里面包含了丰富的命令帮助您进行调试，它的功能和Sun studio里面所带的dbx非常相似，但 jdb是专门用来针对Java应用程序的。 
        现在应该说日常的开发中很少用到JDB了，因为现在的IDE已经帮我们封装好了，如使用ECLI
    
                                
    • 
                                
  • 【Spring框架二】Spring常用注解之Component、Repository、Service和Controller注解
                                    bit1129
controller
                                    
    在Spring常用注解第一步部分【Spring框架一】Spring常用注解之Autowired和Resource注解（http://bit1129.iteye.com/blog/2114084）中介绍了Autowired和Resource两个注解的功能，它们用于将依赖根据名称或者类型进行自动的注入，这简化了在XML中，依赖注入部分的XML的编写，但是UserDao和UserService两个bea
    
                                
    • 
                                
  • cxf wsdl2java生成代码super出错,构造函数不匹配
                                    bitray
super
                                    
        由于过去对于soap协议的cxf接触的不是很多,所以遇到了也是迷糊了一会.后来经过查找资料才得以解决. 初始原因一般是由于jaxws2.2规范和jdk6及以上不兼容导致的.所以要强制降为jaxws2.1进行编译生成.我们需要少量的修改: 
 
我们原来的代码 
wsdl2java com.test.xxx -client http://..... 
修改后的代
    
                                
    • 
                                
  • 动态页面正文部分中文乱码排障一例
                                    ronin47

                                    
    公司网站一部分动态页面，早先使用apache+resin的架构运行，考虑到高并发访问下的响应性能问题，在前不久逐步开始用nginx替换掉了apache。 不过随后发现了一个问题，随意进入某一有分页的网页，第一页是正常的（因为静态化过了）；点“下一页”，出来的页面两边正常，中间部分的标题、关键字等也正常，唯独每个标题下的正文无法正常显示。 因为有做过系统调整，所以第一反应就是新上
    
                                
    • 
                                
  • java-54- 调整数组顺序使奇数位于偶数前面
                                    bylijinnan
java
                                    
    
import java.util.Arrays;
import java.util.Random;

import ljn.help.Helper;


public class OddBeforeEven {

	/**
	 * Q 54 调整数组顺序使奇数位于偶数前面
	 * 输入一个整数数组，调整数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半
    
                                
    • 
                                
  • 从100PV到1亿级PV网站架构演变
                                    cfyme
网站架构
                                    
    一个网站就像一个人，存在一个从小到大的过程。养一个网站和养一个人一样，不同时期需要不同的方法，不同的方法下有共同的原则。本文结合我自已14年网站人的经历记录一些架构演变中的体会。 1：积累是必不可少的 
架构师不是一天练成的。 
1999年，我作了一个个人主页，在学校内的虚拟空间，参加了一次主页大赛，几个DREAMWEAVER的页面，几个TABLE作布局，一个DB连接，几行PHP的代码嵌入在HTM
    
                                
    • 
                                
  • [宇宙时代]宇宙时代的GIS是什么？
                                    comsci
Gis
                                    
     
 
       我们都知道一个事实，在行星内部的时候，因为地理信息的坐标都是相对固定的，所以我们获取一组GIS数据之后，就可以存储到硬盘中，长久使用。。。但是，请注意，这种经验在宇宙时代是不能够被继续使用的 
 
 
         宇宙是一个高维时空
    
                                
    • 
                                
  • 详解create database命令
                                    czmmiao
database
                                    
    完整命令 
CREATE DATABASE mynewdb   USER SYS IDENTIFIED BY sys_password   USER SYSTEM IDENTIFIED BY system_password   LOGFILE GROUP 1 ('/u01/logs/my/redo01a.log','/u02/logs/m
    
                                
    • 
                                
  • 几句不中听却不得不认可的话
                                    datageek

                                    
    1、人丑就该多读书。 
2、你不快乐是因为：你可以像猪一样懒，却无法像只猪一样懒得心安理得。 
3、如果你太在意别人的看法，那么你的生活将变成一件裤衩，别人放什么屁，你都得接着。 
4、你的问题主要在于：读书不多而买书太多，读书太少又特爱思考，还他妈话痨。 
5、与禽兽搏斗的三种结局：(1)、赢了，比禽兽还禽兽。(2)、输了，禽兽不如。(3)、平了，跟禽兽没两样。结论：选择正确的对手很重要。 
6
    
                                
    • 
                                
  • 1 14:00 PHP中的“syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM”错误
                                    dcj3sjt126com
PHP
                                    
    原文地址：http://www.kafka0102.com/2010/08/281.html 
  
因为需要，今天晚些在本机使用PHP做些测试，PHP脚本依赖了一堆我也不清楚做什么用的库。结果一跑起来，就报出类似下面的错误：“Parse error: syntax error, unexpected T_PAAMAYIM_NEKUDOTAYIM in /home/kafka/test/
    
                                
    • 
                                
  • xcode6 Auto layout and size classes
                                    dcj3sjt126com
ios
                                    
    官方GUI 
  
https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/AutolayoutPG/Introduction/Introduction.html 
  
iOS中使用自动布局（一） 
  
http://www.cocoachina.com/ind
    
                                
    • 
                                
  • 通过PreparedStatement批量执行sql语句【sql语句相同，值不同】
                                    梦见x光
sql事务批量执行
                                    
    比如说：我有一个List需要添加到数据库中，那么我该如何通过PreparedStatement来操作呢？ 
public void addCustomerByCommit(Connection conn , List<Customer> customerList) 
{ 
   String sql = "inseret into customer(id 
    
                                
    • 
                                
  • 程序员必知必会----linux常用命令之十【系统相关】
                                    hanqunfeng
Linux常用命令
                                    
    一.linux快捷键 
Ctrl+C : 终止当前命令 
Ctrl+S : 暂停屏幕输出 
Ctrl+Q : 恢复屏幕输出 
Ctrl+U : 删除当前行光标前的所有字符 
Ctrl+Z : 挂起当前正在执行的进程 
Ctrl+L : 清除终端屏幕，相当于clear 
  
二.终端命令 
clear : 清除终端屏幕 
reset : 重置视窗，当屏幕编码混乱时使用 
time com
    
                                
    • 
                                
  • NGINX
                                    IXHONG
nginx
                                    
    pcre 编译安装 nginx 
conf/vhost/test.conf 
  
upstream admin { 
server 127.0.0.1:8080; 
} 
  
server { 
                listen       80; 
&
    
                                
    • 
                                
  • 设计模式--工厂模式
                                    kerryg
设计模式
                                    
    工厂方式模式分为三种： 
  1、普通工厂模式：建立一个工厂类，对实现了同一个接口的一些类进行实例的创建。 
 
  2、多个工厂方法的模式：就是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式就是提供多个工厂方法，分别创建对象。 
 
  3、静态工厂方法模式：就是将上面的多个工厂方法模式里的方法置为静态，
    
                                
    • 
                                
  • Spring InitializingBean/init-method和DisposableBean/destroy-method
                                    mx_xiehd
javaspringbeanxml
                                    
    1.initializingBean/init-method 
实现org.springframework.beans.factory.InitializingBean接口允许一个bean在它的所有必须属性被BeanFactory设置后，来执行初始化的工作，InitialzingBean仅仅指定了一个方法。 
通常InitializingBean接口的使用是能够被避免的，（不鼓励使用，因为没有必要
    
                                
    • 
                                
  • 解决Centos下vim粘贴内容格式混乱问题
                                    qindongliang1922
centosvim
                                    
     
 
有时候，我们在向vim打开的一个xml，或者任意文件中，拷贝粘贴的代码时，格式莫名其毛的就混乱了，然后自己一个个再重新，把格式排列好，非常耗时，而且很不爽，那么有没有办法避免呢？  答案是肯定的，设置下缩进格式就可以了，非常简单：  在用户的根目录下 直接vi  ~/.vimrc文件 然后将set pastetoggle=<F9> 写入这个文件中，保存退出，重新登录，
    
                                
    • 
                                
  • netty大并发请求问题
                                    tianzhihehe
netty
                                    
    多线程并发使用同一个channel 
java.nio.BufferOverflowException: null 
at java.nio.HeapByteBuffer.put(HeapByteBuffer.java:183) ~[na:1.7.0_60-ea] 
at java.nio.ByteBuffer.put(ByteBuffer.java:832) ~[na:1.7.0_60-ea] 
    
                                
    • 
                                
  • Hadoop NameNode单点问题解决方案之一 AvatarNode
                                    wyz2009107220
NameNode
                                    
    我们遇到的情况 
Hadoop NameNode存在单点问题。这个问题会影响分布式平台24*7运行。先说说我们的情况吧。 
我们的团队负责管理一个1200节点的集群(总大小12PB)，目前是运行版本为Hadoop 0.20，transaction logs写入一个共享的NFS filer(注：NetApp NFS Filer)。 
经常遇到需要中断服务的问题是给hadoop打补丁。 DataNod
    
                                
    •