30个类手写Spring核心原理之AOP代码织入（5）

本文节选自《Spring 5核心原理》

前面我们已经完成了Spring IoC、DI、MVC三大核心模块的功能，并保证了功能可用。接下来要完成Spring的另一个核心模块—AOP，这也是最难的部分。

1 基础配置

首先，在application.properties中增加如下自定义配置，作为Spring AOP的基础配置：


#多切面配置可以在key前面加前缀
#例如 aspect.logAspect.

#切面表达式#
pointCut=public .* com.tom.spring.demo.service..*Service..*(.*)
#切面类#
aspectClass=com.tom.spring.demo.aspect.LogAspect
#切面前置通知#
aspectBefore=before
#切面后置通知#
aspectAfter=after
#切面异常通知#
aspectAfterThrow=afterThrowing
#切面异常类型#
aspectAfterThrowingName=java.lang.Exception

为了加强理解，我们对比一下Spring AOP的原生配置：

为了方便，我们用properties文件来代替XML，以简化操作。

2 AOP核心原理V1.0版本

AOP的基本实现原理是利用动态代理机制，创建一个新的代理类完成代码织入，以达到代码功能增强的目的。如果各位小伙伴对动态代理原理不太了解的话，可以回看一下我前段时间更新的“设计模式就该这样学”系列中的动态代理模式专题文章。那么Spring AOP又是如何利用动态代理工作的呢？其实Spring主要功能就是完成解耦，将我们需要增强的代码逻辑单独拆离出来放到专门的类中，然后，通过声明配置文件来关联这些已经被拆离的逻辑，最后合并到一起运行。Spring容器为了保存这种关系，我们可以简单的理解成Spring是用一个Map保存保存这种关联关系的。Map的key就是我们要调用的目标方法，Map的value就是我们要织入的方法。只不过要织入的方法有前后顺序，因此我们需要标记织入方法的位置。在目标方法前面织入的逻辑叫做前置通知，在目标方法后面织入的逻辑叫后置通知，在目标方法出现异常时需要织入的逻辑叫异常通知。Map的具体设计如下：


private Map> methodAdvices = new HashMap>();

下面我完整的写出一个简易的ApplicationContex，小伙伴可以参考 一下：


import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;



public class GPApplicationContext {
    private Properties contextConfig = new Properties();
    private Map ioc = new HashMap();
    //用来保存配置文件中对应的Method和Advice的对应关系
    private Map> methodAdvices = new HashMap>();


    public GPApplicationContext(){
        
           //为了演示，手动初始化一个Bean
             
        ioc.put("memberService", new MemberService());

        doLoadConfig("application.properties");

        doInitAopConfig();

    }

    public Object getBean(String name){
        return createProxy(ioc.get(name));
    }


    private Object createProxy(Object instance){
        return new GPJdkDynamicAopProxy(instance).getProxy();
    }

    //加载配置文件
    private void doLoadConfig(String contextConfigLocation) {
        //直接从类路径下找到Spring主配置文件所在的路径
        //并且将其读取出来放到Properties对象中
        //相对于scanPackage=com.gupaoedu.demo 从文件中保存到了内存中
        InputStream is = this.getClass().getClassLoader().getResourceAsStream(contextConfigLocation);
        try {
            contextConfig.load(is);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != is){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private void doInitAopConfig() {

        try {
            Class apectClass = Class.forName(contextConfig.getProperty("aspectClass"));
            Map aspectMethods = new HashMap();
            for (Method method : apectClass.getMethods()) {
                aspectMethods.put(method.getName(),method);
            }

            //PonintCut  表达式解析为正则表达式
            String pointCut = contextConfig.getProperty("pointCut")
                    .replaceAll("\\.","\\\\.")
                    .replaceAll("\\\\.\\*",".*")
                    .replaceAll("\\(","\\\\(")
                    .replaceAll("\\)","\\\\)");
            Pattern pointCutPattern = Pattern.compile(pointCut);

            for (Map.Entry entry : ioc.entrySet()) {
                Class clazz = entry.getValue().getClass();
                //循环找到所有的方法
                for (Method method : clazz.getMethods()) {
                    //保存方法名
                    String methodString = method.toString();
                    if(methodString.contains("throws")){
                        methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
                    }
                    Matcher matcher = pointCutPattern.matcher(methodString);
                    if(matcher.matches()){
                        Map advices = new HashMap();
                        if(!(null == contextConfig.getProperty("aspectBefore") || "".equals( contextConfig.getProperty("aspectBefore")))){
                            advices.put("before",aspectMethods.get(contextConfig.getProperty("aspectBefore")));
                        }
                        if(!(null ==  contextConfig.getProperty("aspectAfter") || "".equals( contextConfig.getProperty("aspectAfter")))){
                            advices.put("after",aspectMethods.get(contextConfig.getProperty("aspectAfter")));
                        }
                        if(!(null == contextConfig.getProperty("aspectAfterThrow") || "".equals( contextConfig.getProperty("aspectAfterThrow")))){
                            advices.put("afterThrow",aspectMethods.get(contextConfig.getProperty("aspectAfterThrow")));
                        }
                        methodAdvices.put(method,advices);
                    }
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }

    class GPJdkDynamicAopProxy implements GPInvocationHandler {
        private Object instance;
        public GPJdkDynamicAopProxy(Object instance) {
            this.instance = instance;
        }

        public Object getProxy() {
            return Proxy.newProxyInstance(instance.getClass().getClassLoader(),instance.getClass().getInterfaces(),this);
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object aspectObject = Class.forName(contextConfig.getProperty("aspectClass")).newInstance();
            Map advices = methodAdvices.get(instance.getClass().getMethod(method.getName(),method.getParameterTypes()));
            Object returnValue = null;
            advices.get("before").invoke(aspectObject);
            try {
                returnValue = method.invoke(instance, args);
            }catch (Exception e){
                advices.get("afterThrow").invoke(aspectObject);
                e.printStackTrace();
                throw e;
            }
            advices.get("after").invoke(aspectObject);
            return returnValue;
        }
    }

}

测试代码：


public class MemberServiceTest {


    public static void main(String[] args) {
        GPApplicationContext applicationContext = new GPApplicationContext();
        IMemberService memberService = (IMemberService)applicationContext.getBean("memberService");

        try {

            memberService.get("1");
            memberService.save(new Member());

        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

我们通过简单几百行代码，就可以完整地演示Spring AOP的核心原理，是不是很简单呢？当然，小伙伴们还是要自己动手哈亲自体验一下，这样才会印象深刻。下面，我们继续完善，将Spring AOP 1.0升级到2.0，那么2.0版本我是完全仿真Spring的原始设计来写的，希望能够给大家带来不一样的手写体验，从而更加深刻地理解Spring AOP的原理。

3 完成AOP顶层设计

3.1 GPJoinPoint

定义一个切点的抽象，这是AOP的基础组成单元。我们可以理解为这是某一个业务方法的附加信息。可想而知，切点应该包含业务方法本身、实参列表和方法所属的实例对象，还可以在GPJoinPoint中添加自定义属性，看下面的代码：


package com.tom.spring.formework.aop.aspect;

import java.lang.reflect.Method;

/**
 * 回调连接点，通过它可以获得被代理的业务方法的所有信息
 */
public interface GPJoinPoint {

    Method getMethod(); //业务方法本身

    Object[] getArguments();  //该方法的实参列表

    Object getThis(); //该方法所属的实例对象

    //在JoinPoint中添加自定义属性
    void setUserAttribute(String key, Object value);
    //从已添加的自定义属性中获取一个属性值
    Object getUserAttribute(String key);

}

3.2 GPMethodInterceptor

方法拦截器是AOP代码增强的基本组成单元，其子类主要有GPMethodBeforeAdvice、GPAfterReturningAdvice和GPAfterThrowingAdvice。


package com.tom.spring.formework.aop.intercept;

/**
 * 方法拦截器顶层接口
 */ 
public interface GPMethodInterceptor{
    Object invoke(GPMethodInvocation mi) throws Throwable;
}

3.3 GPAopConfig

定义AOP的配置信息的封装对象，以方便在之后的代码中相互传递。


package com.tom.spring.formework.aop;

import lombok.Data;

/**
 * AOP配置封装
 */
@Data
public class GPAopConfig {
//以下配置与properties文件中的属性一一对应
    private String pointCut;  //切面表达式
    private String aspectBefore;  //前置通知方法名
    private String aspectAfter;  //后置通知方法名
    private String aspectClass;  //要织入的切面类
    private String aspectAfterThrow;  //异常通知方法名
    private String aspectAfterThrowingName;  //需要通知的异常类型
}

3.4 GPAdvisedSupport

GPAdvisedSupport主要完成对AOP配置的解析。其中pointCutMatch()方法用来判断目标类是否符合切面规则，从而决定是否需要生成代理类，对目标方法进行增强。而getInterceptorsAndDynamic- InterceptionAdvice()方法主要根据AOP配置，将需要回调的方法封装成一个拦截器链并返回提供给外部获取。


package com.tom.spring.formework.aop.support;

import com.tom.spring.formework.aop.GPAopConfig;
import com.tom.spring.formework.aop.aspect.GPAfterReturningAdvice;
import com.tom.spring.formework.aop.aspect.GPAfterThrowingAdvice;
import com.tom.spring.formework.aop.aspect.GPMethodBeforeAdvice;

import java.lang.reflect.Method;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 主要用来解析和封装AOP配置
 */
public class GPAdvisedSupport {
    private Class targetClass;
    private Object target;
    private Pattern pointCutClassPattern;

    private transient Map> methodCache;

    private GPAopConfig config;

    public GPAdvisedSupport(GPAopConfig config){
        this.config = config;
    }

    public Class getTargetClass() {
        return targetClass;
    }

    public void setTargetClass(Class targetClass) {
        this.targetClass = targetClass;
        parse();
    }

    public Object getTarget() {
        return target;
    }

    public void setTarget(Object target) {
        this.target = target;
    }

    public List getInterceptorsAndDynamicInterceptionAdvice(Method method, Class targetClass) throws Exception {
        List cached = methodCache.get(method);

        //缓存未命中，则进行下一步处理
        if (cached == null) {
           Method m = targetClass.getMethod(method.getName(),method.getParameterTypes());
           cached = methodCache.get(m);
            //存入缓存
            this.methodCache.put(m, cached);
        }
        return cached;
    }

    public boolean pointCutMatch(){
        return pointCutClassPattern.matcher(this.targetClass.toString()).matches();
    }

    private void parse(){
        //pointCut表达式
        String pointCut = config.getPointCut()
                .replaceAll("\\.","\\\\.")
                .replaceAll("\\\\.\\*",".*")
                .replaceAll("\\(","\\\\(")
                .replaceAll("\\)","\\\\)");

        String pointCutForClass = pointCut.substring(0,pointCut.lastIndexOf("\\(") - 4);
        pointCutClassPattern = Pattern.compile("class " + pointCutForClass.substring (pointCutForClass.lastIndexOf(" ")+1));

        methodCache = new HashMap>();
        Pattern pattern = Pattern.compile(pointCut);

        try {
            Class aspectClass = Class.forName(config.getAspectClass());
            Map aspectMethods = new HashMap();
            for (Method m : aspectClass.getMethods()){
                aspectMethods.put(m.getName(),m);
            }

            //在这里得到的方法都是原生方法
            for (Method m : targetClass.getMethods()){

                String methodString = m.toString();
                if(methodString.contains("throws")){
                    methodString = methodString.substring(0,methodString.lastIndexOf("throws")).trim();
                }
                Matcher matcher = pattern.matcher(methodString);
                if(matcher.matches()){
                    //能满足切面规则的类，添加到AOP配置中
                    List advices = new LinkedList();
                    //前置通知
                    if(!(null == config.getAspectBefore() || "".equals(config.getAspectBefore().trim()))) {
                        advices.add(new GPMethodBeforeAdvice(aspectMethods.get (config.getAspectBefore()), aspectClass.newInstance()));
                    }
                    //后置通知
                    if(!(null == config.getAspectAfter() || "".equals(config.getAspectAfter(). trim()))) {
                        advices.add(new GPAfterReturningAdvice(aspectMethods.get (config.getAspectAfter()), aspectClass.newInstance()));
                    }
                    //异常通知
                    if(!(null == config.getAspectAfterThrow() || "".equals(config.getAspectAfterThrow().trim()))) {
                        GPAfterThrowingAdvice afterThrowingAdvice = new GPAfterThrowingAdvice (aspectMethods.get(config.getAspectAfterThrow()), aspectClass.newInstance());
                        afterThrowingAdvice.setThrowingName(config.getAspectAfterThrowingName());
                        advices.add(afterThrowingAdvice);
                    }
                    methodCache.put(m,advices);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}
 
 
3.5 GPAopProxy
 
 
GPAopProxy是代理工厂的顶层接口，其子类主要有两个：GPCglibAopProxy和GPJdkDynamicAopProxy，分别实现CGlib代理和JDK Proxy代理。
 
 

package com.tom.spring.formework.aop;
/**
 * 代理工厂的顶层接口，提供获取代理对象的顶层入口 
 */
//默认就用JDK动态代理
public interface GPAopProxy {
//获得一个代理对象
    Object getProxy();
//通过自定义类加载器获得一个代理对象
    Object getProxy(ClassLoader classLoader);
}

 
 
3.6 GPCglibAopProxy
 
 
本文未实现CglibAopProxy，感兴趣的“小伙伴”可以自行尝试。
 
 

package com.tom.spring.formework.aop;

import com.tom.spring.formework.aop.support.GPAdvisedSupport;

/**
 * 使用CGlib API生成代理类，在此不举例
 * 感兴趣的“小伙伴”可以自行实现
 */
public class GPCglibAopProxy implements GPAopProxy {
    private GPAdvisedSupport config;

    public GPCglibAopProxy(GPAdvisedSupport config){
        this.config = config;
    }

    @Override
    public Object getProxy() {
        return null;
    }

    @Override
    public Object getProxy(ClassLoader classLoader) {
        return null;
    }
}

 
 
3.7 GPJdkDynamicAopProxy
 
 
下面来看GPJdkDynamicAopProxy的实现，主要功能在invoke()方法中。从代码量来看其实不多，主要是调用了GPAdvisedSupport的getInterceptorsAndDynamicInterceptionAdvice()方法获得拦截器链。在目标类中，每一个被增强的目标方法都对应一个拦截器链。
 
 

package com.tom.spring.formework.aop;

import com.tom.spring.formework.aop.intercept.GPMethodInvocation;
import com.tom.spring.formework.aop.support.GPAdvisedSupport;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.List;

/**
 * 使用JDK Proxy API生成代理类
 */
public class GPJdkDynamicAopProxy implements GPAopProxy,InvocationHandler {
    private GPAdvisedSupport config;

    public GPJdkDynamicAopProxy(GPAdvisedSupport config){
        this.config = config;
    }

    //把原生的对象传进来
    public Object getProxy(){
        return getProxy(this.config.getTargetClass().getClassLoader());
    }

    @Override
    public Object getProxy(ClassLoader classLoader) {
        return Proxy.newProxyInstance(classLoader,this.config.getTargetClass().getInterfaces(),this);
    }

    //invoke()方法是执行代理的关键入口
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//将每一个JoinPoint也就是被代理的业务方法（Method）封装成一个拦截器，组合成一个拦截器链
        List interceptorsAndDynamicMethodMatchers = config.getInterceptorsAndDynamicInterceptionAdvice(method,this.config.getTargetClass());
//交给拦截器链MethodInvocation的proceed()方法执行
        GPMethodInvocation invocation = new GPMethodInvocation(proxy,this.config.getTarget(), method,args,this.config.getTargetClass(),interceptorsAndDynamicMethodMatchers);
        return invocation.proceed();
    }
}
 
 
从代码中可以看出，从GPAdvisedSupport中获得的拦截器链又被当作参数传入GPMethodInvocation的构造方法中。那么GPMethodInvocation中到底又对方法链做了什么呢？
 
 
3.8 GPMethodInvocation
 
 
GPMethodInvocation的代码如下：
 
 

package com.tom.spring.formework.aop.intercept;

import com.tom.spring.formework.aop.aspect.GPJoinPoint;

import java.lang.reflect.Method;
import java.util.List;

/**
 * 执行拦截器链，相当于Spring中ReflectiveMethodInvocation的功能
 */
public class GPMethodInvocation implements GPJoinPoint {

    private Object proxy; //代理对象
    private Method method; //代理的目标方法
    private Object target; //代理的目标对象
    private Class targetClass; //代理的目标类
    private Object[] arguments; //代理的方法的实参列表
    private List interceptorsAndDynamicMethodMatchers; //回调方法链

//保存自定义属性
private Map userAttributes;


    private int currentInterceptorIndex = -1;

    public GPMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
                              Class targetClass, List interceptorsAndDynamicMethodMatchers) {
        this.proxy = proxy;
        this.target = target;
        this.targetClass = targetClass;
        this.method = method;
        this.arguments = arguments;
        this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
    }

    public Object proceed() throws Throwable {
//如果Interceptor执行完了，则执行joinPoint
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return this.method.invoke(this.target,this.arguments);
        }
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
//如果要动态匹配joinPoint
if (interceptorOrInterceptionAdvice instanceof GPMethodInterceptor) {
            GPMethodInterceptor mi = (GPMethodInterceptor) interceptorOrInterceptionAdvice;
            return mi.invoke(this);
        } else {
//执行当前Intercetpor

            return proceed();
        }

    }

    @Override
    public Method getMethod() {
        return this.method;
    }

    @Override
    public Object[] getArguments() {
        return this.arguments;
    }

    @Override
    public Object getThis() {
        return this.target;
    }

public void setUserAttribute(String key, Object value) {
      if (value != null) {
          if (this.userAttributes == null) {
              this.userAttributes = new HashMap();
          }
          this.userAttributes.put(key, value);
      }
      else {
          if (this.userAttributes != null) {
              this.userAttributes.remove(key);
          }
      }
  }


  public Object getUserAttribute(String key) {
      return (this.userAttributes != null ? this.userAttributes.get(key) : null);
  }

}
 
 
从代码中可以看出，proceed()方法才是MethodInvocation的关键所在。在proceed()中，先进行判断，如果拦截器链为空，则说明目标方法无须增强，直接调用目标方法并返回。如果拦截器链不为空，则将拦截器链中的方法按顺序执行，直到拦截器链中所有方法全部执行完毕。
 
 
4 设计AOP基础实现
 
 
4.1 GPAdvice
 
 
GPAdvice作为所有回调通知的顶层接口设计，在Mini版本中为了尽量和原生Spring保持一致，只是被设计成了一种规范，并没有实现任何功能。
 
 

/**
 * 回调通知顶层接口
 */
public interface GPAdvice {

}

 
 
4.2 GPAbstractAspectJAdvice
 
 
使用模板模式设计GPAbstractAspectJAdvice类，封装拦截器回调的通用逻辑，主要封装反射动态调用方法，其子类只需要控制调用顺序即可。
 
 

package com.tom.spring.formework.aop.aspect;

import java.lang.reflect.Method;

/**
 * 封装拦截器回调的通用逻辑，在Mini版本中主要封装了反射动态调用方法
 */
public abstract class GPAbstractAspectJAdvice implements GPAdvice {

    private Method aspectMethod;
    private Object aspectTarget;

    public GPAbstractAspectJAdvice(
            Method aspectMethod, Object aspectTarget) {
            this.aspectMethod = aspectMethod;
            this.aspectTarget = aspectTarget;
    }

    //反射动态调用方法
    protected Object invokeAdviceMethod(GPJoinPoint joinPoint,Object returnValue,Throwable ex)
            throws Throwable {
        Class [] paramsTypes = this.aspectMethod.getParameterTypes();
        if(null == paramsTypes || paramsTypes.length == 0) {
            return this.aspectMethod.invoke(aspectTarget);
        }else {
            Object[] args = new Object[paramsTypes.length];
            for (int i = 0; i < paramsTypes.length; i++) {
                if(paramsTypes[i] == GPJoinPoint.class){
                    args[i] = joinPoint;
                }else if(paramsTypes[i] == Throwable.class){
                    args[i] = ex;
                }else if(paramsTypes[i] == Object.class){
                    args[i] = returnValue;
                }
            }
            return this.aspectMethod.invoke(aspectTarget,args);
        }
    }
}

 
 
4.3 GPMethodBeforeAdvice
 
 
GPMethodBeforeAdvice继承GPAbstractAspectJAdvice，实现GPAdvice和GPMethodInterceptor接口，在invoke()中控制前置通知的调用顺序。
 
 

package com.tom.spring.formework.aop.aspect;

import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;

import java.lang.reflect.Method;

/**
 * 前置通知具体实现
 */
public class GPMethodBeforeAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {

    private GPJoinPoint joinPoint;

    public GPMethodBeforeAdvice(Method aspectMethod, Object target) {
        super(aspectMethod, target);
    }

    public void before(Method method, Object[] args, Object target) throws Throwable {
        invokeAdviceMethod(this.joinPoint,null,null);
    }

    public Object invoke(GPMethodInvocation mi) throws Throwable {
        this.joinPoint = mi;
        this.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();
    }
}

 
 
4.4 GPAfterReturningAdvice
 
 
GPAfterReturningAdvice继承GPAbstractAspectJAdvice，实现GPAdvice和GPMethodInterceptor接口，在invoke()中控制后置通知的调用顺序。
 
 

package com.tom.spring.formework.aop.aspect;

import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;

import java.lang.reflect.Method;

/**
 * 后置通知具体实现
 */
public class GPAfterReturningAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {

    private GPJoinPoint joinPoint;
    public GPAfterReturningAdvice(Method aspectMethod, Object target) {
        super(aspectMethod, target);
    }

    @Override
    public Object invoke(GPMethodInvocation mi) throws Throwable {
        Object retVal = mi.proceed();
        this.joinPoint = mi;
        this.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
        return retVal;
    }

    public void afterReturning(Object returnValue, Method method, Object[] args,Object target) throws Throwable{
        invokeAdviceMethod(joinPoint,returnValue,null);
    }

}

 
 
4.5 GPAfterThrowingAdvice
 
 
GPAfterThrowingAdvice继承GPAbstractAspectJAdvice，实现GPAdvice和GPMethodInterceptor接口，在invoke()中控制异常通知的调用顺序。
 
 

package com.tom.spring.formework.aop.aspect;

import com.tom.spring.formework.aop.intercept.GPMethodInterceptor;
import com.tom.spring.formework.aop.intercept.GPMethodInvocation;

import java.lang.reflect.Method;

/**
 * 异常通知具体实现
 */
public class GPAfterThrowingAdvice extends GPAbstractAspectJAdvice implements GPAdvice, GPMethodInterceptor {

    private String throwingName;
    private GPMethodInvocation mi;

    public GPAfterThrowingAdvice(Method aspectMethod, Object target) {
        super(aspectMethod, target);
    }

    public void setThrowingName(String name) {
        this.throwingName = name;
    }

    @Override
    public Object invoke(GPMethodInvocation mi) throws Throwable {
        try {
            return mi.proceed();
        }catch (Throwable ex) {
            invokeAdviceMethod(mi,null,ex.getCause());
            throw ex;
        }
    }
}

 
 
感兴趣的“小伙伴”可以参看Spring源码，自行实现环绕通知的调用逻辑。
 
 
4.6 接入getBean()方法
 
 
在上面的代码中，我们已经完成了Spring AOP模块的核心功能，那么接下如何集成到IoC容器中去呢？找到GPApplicationContext的getBean()方法，我们知道getBean()中负责Bean初始化的方法其实就是instantiateBean()，在初始化时就可以确定是否返回原生Bean或Proxy Bean。代码实现如下：
 
 

//传一个BeanDefinition，返回一个实例Bean
private Object instantiateBean(GPBeanDefinition beanDefinition){
    Object instance = null;
    String className = beanDefinition.getBeanClassName();
    try{

        //因为根据Class才能确定一个类是否有实例
        if(this.singletonBeanCacheMap.containsKey(className)){
            instance = this.singletonBeanCacheMap.get(className);
        }else{
            Class clazz = Class.forName(className);
            instance = clazz.newInstance();

            GPAdvisedSupport config = instantionAopConfig(beanDefinition);
            config.setTargetClass(clazz);
            config.setTarget(instance);

            if(config.pointCutMatch()) {
                instance = createProxy(config).getProxy();
            }
          this.factoryBeanObjectCache.put(className,instance);
            this.singletonBeanCacheMap.put(beanDefinition.getFactoryBeanName(),instance);
        }

        return instance;
    }catch (Exception e){
        e.printStackTrace();
    }

    return null;
}

private GPAdvisedSupport instantionAopConfig(GPBeanDefinition beanDefinition) throws  Exception{

    GPAopConfig config = new GPAopConfig();
    config.setPointCut(reader.getConfig().getProperty("pointCut"));
    config.setAspectClass(reader.getConfig().getProperty("aspectClass"));
    config.setAspectBefore(reader.getConfig().getProperty("aspectBefore"));
    config.setAspectAfter(reader.getConfig().getProperty("aspectAfter"));
    config.setAspectAfterThrow(reader.getConfig().getProperty("aspectAfterThrow"));
    config.setAspectAfterThrowingName(reader.getConfig().getProperty("aspectAfterThrowingName"));

    return new GPAdvisedSupport(config);
}

private GPAopProxy createProxy(GPAdvisedSupport config) {
    Class targetClass = config.getTargetClass();
    if (targetClass.getInterfaces().length > 0) {
        return new GPJdkDynamicAopProxy(config);
    }
    return new GPCglibAopProxy(config);
}

 
 
从上面的代码中可以看出，在instantiateBean()方法中调用createProxy()决定代理工厂的调用策略，然后调用代理工厂的proxy()方法创建代理对象。最终代理对象将被封装到BeanWrapper中并保存到IoC容器。
 
 
5 织入业务代码
 
 
通过前面的代码编写，所有的核心模块和底层逻辑都已经实现，“万事俱备，只欠东风。”接下来，该是“见证奇迹的时刻了”。我们来织入业务代码，做一个测试。创建LogAspect类，实现对业务方法的监控。主要记录目标方法的调用日志，获取目标方法名、实参列表、每次调用所消耗的时间。
 
 
5.1 LogAspect
 
 
LogAspect的代码如下：
 
 

package com.tom.spring.demo.aspect;

import com.tom.spring.formework.aop.aspect.GPJoinPoint;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;

/**
 * 定义一个织入的切面逻辑，也就是要针对目标代理对象增强的逻辑
 * 本类主要完成对方法调用的监控，监听目标方法每次执行所消耗的时间
 */
@Slf4j
public class LogAspect {

    //在调用一个方法之前，执行before()方法
    public void before(GPJoinPoint joinPoint){
        joinPoint.setUserAttribute("startTime_" + joinPoint.getMethod().getName(),System.currentTimeMillis());
        //这个方法中的逻辑是由我们自己写的
        log.info("Invoker Before Method!!!" +
                "\nTargetObject:" +  joinPoint.getThis() +
                "\nArgs:" + Arrays.toString(joinPoint.getArguments()));
    }

    //在调用一个方法之后，执行after()方法
    public void after(GPJoinPoint joinPoint){
        log.info("Invoker After Method!!!" +
                "\nTargetObject:" +  joinPoint.getThis() +
                "\nArgs:" + Arrays.toString(joinPoint.getArguments()));
        long startTime = (Long) joinPoint.getUserAttribute("startTime_" + joinPoint.getMethod().getName());
        long endTime = System.currentTimeMillis();
        System.out.println("use time :" + (endTime - startTime));
    }

    public void afterThrowing(GPJoinPoint joinPoint, Throwable ex){
        log.info("出现异常" +
                "\nTargetObject:" +  joinPoint.getThis() +
                "\nArgs:" + Arrays.toString(joinPoint.getArguments()) +
                "\nThrows:" + ex.getMessage());
    }
}

 
 
通过上面的代码可以发现，每一个回调方法都加了一个参数GPJoinPoint，还记得GPJoinPoint为何物吗？事实上，GPMethodInvocation就是GPJoinPoint的实现类。而GPMethodInvocation又是在GPJdkDynamicAopPorxy的invoke()方法中实例化的，即每个被代理对象的业务方法会对应一个GPMethodInvocation实例。也就是说，MethodInvocation的生命周期是被代理对象中业务方法的生命周期的对应。前面我们已经了解，调用GPJoinPoint的setUserAttribute()方法可以在GPJoinPoint中自定义属性，调用getUserAttribute()方法可以获取自定义属性的值。
在LogAspect的before()方法中，在GPJoinPoint中设置了startTime并赋值为系统时间，即记录方法开始调用时间到MethodInvocation的上下文。在LogAspect的after()方法中获取startTime，再次获取的系统时间保存到endTime。在AOP拦截器链回调中，before()方法肯定在after()方法之前调用，因此两次获取的系统时间会形成一个时间差，这个时间差就是业务方法执行所消耗的时间。通过这个时间差，就可以判断业务方法在单位时间内的性能消耗，是不是设计得非常巧妙？事实上，市面上几乎所有的系统监控框架都是基于这样一种思想来实现的，可以高度解耦并减少代码侵入。
 
 
5.2 IModifyService
 
 
为了演示异常回调通知，我们给之前定义的IModifyService接口的add()方法添加了抛出异常的功能，看下面的代码实现：
 
 

package com.tom.spring.demo.service;

/**
 * 增、删、改业务
  */
public interface IModifyService {

   /**
    * 增加
    */
   String add(String name, String addr) throws Exception;
   
   /**
    * 修改
    */
   String edit(Integer id, String name);
   
   /**
    * 删除
    */
   String remove(Integer id);
   
}

 
 
5.3 ModifyService
 
 
ModifyService的代码如下：
 
 

package com.tom.spring.demo.service.impl;

import com.tom.spring.demo.service.IModifyService;
import com.tom.spring.formework.annotation.GPService;

/**
 * 增、删、改业务
 */
@GPService
public class ModifyService implements IModifyService {

   /**
    * 增加
    */
   public String add(String name,String addr) throws Exception {
      throw new Exception("故意抛出异常，测试切面通知是否生效");
//    return "modifyService add,name=" + name + ",addr=" + addr;
   }

   /**
    * 修改
    */
   public String edit(Integer id,String name) {
      return "modifyService edit,id=" + id + ",name=" + name;
   }

   /**
    * 删除
    */
   public String remove(Integer id) {
      return "modifyService id=" + id;
   }
}

 
 
6 运行效果演示
 
 
在浏览器中输入 http://localhost/web/add.json... ，就可以直观明了地看到Service层抛出的异常信息，如下图所示。
 
 
30个类手写Spring核心原理之AOP代码织入（5）_第1张图片
 
 
控制台输出如下图所示。
 
 
file
 
 
通过控制台输出，可以看到异常通知成功捕获异常信息，触发了GPMethodBeforeAdvice 和GPAfterThrowingAdvice，而并未触发GPAfterReturningAdvice，符合我们的预期。
下面再做一个测试，输入 http://localhost/web/query.js... ，结果如下图所示：
 
 
30个类手写Spring核心原理之AOP代码织入（5）_第2张图片
 
 
控制台输出如下图所示：
 
 
30个类手写Spring核心原理之AOP代码织入（5）_第3张图片
 
 
通过控制台输出可以看到，分别捕获了前置通知、后置通知，并打印了相关信息，符合我们的预期。
 
 
至此AOP模块大功告成，是不是有一种小小的成就感，跃跃欲试？在整个Mini版本实现中有些细节没有过多考虑，更多的是希望给“小伙伴们”提供一种学习源码的思路。手写源码不是为了重复造轮子，也不是为了装“高大上”，其实只是我们推荐给大家的一种学习方式。
 
 
关注微信公众号『 Tom弹架构 』回复“Spring”可获取完整源码。
 
 

   本文为“Tom弹架构”原创，转载请注明出处。技术在于分享，我分享我快乐！如果您有任何建议也可留言评论或私信，您的支持是我坚持创作的动力。关注微信公众号『 Tom弹架构 』可获取更多技术干货！ 
 
 
 
原创不易，坚持很酷，都看到这里了，小伙伴记得点赞、收藏、在看，一键三连加关注！如果你觉得内容太干，可以分享转发给朋友滋润滋润！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(javaspring源码)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • 00. 这里整理了最全的爬虫框架（Java + Python）
                        有一只柴犬
爬虫系列爬虫javapython
                        
    目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
    
                    
    • 
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • JavaScript `Map` 和 `WeakMap`详细解释
                        跳房子的前端
JavaScript原生方法javascript前端开发语言
                        
    在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
    
                    
    • 
                    
  • 切换淘宝最新npm镜像源是
                        hai40587
npm前端node.js
                        
    切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
    
                    
    • 
                    
  • 【Java】已解决：java.util.concurrent.CompletionException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
    
                    
    • 
                    
  • 设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
                        ok!ko
设计模式设计模式建造者模式java
                        
    文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
    
                    
    • 
                                
  • 解读Servlet原理篇二---GenericServlet与HttpServlet
                                    周凡杨
javaHttpServlet源理GenericService源码
                                    
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
    
                                
    • 
                                
  • MySQL性能优化
                                    bijian1013
数据库mysql
                                    
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有： 
        a.优化查询 
        b.优化数据库结构 
  
    
                                
    • 
                                
  • ThreadPool定时重试
                                    dai_lm
javaThreadPoolthreadtimertimertask
                                    
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 
由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 
为了解决不定间隔的重试，选择Timer和TimerTask来完成 
 
 

package threadpool;

public class ThreadPoolTest {


    
                                
    • 
                                
  • Oracle 查看数据库的连接情况
                                    周凡杨
sqloracle 连接
                                    
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 
 
select * from dict where table_name like '%SESSION%'; 
就可以查出一些表，然后根据这些表就可以获得会话信息 
 
select sid,serial#,status,username,schemaname,osuser,terminal,ma
    
                                
    • 
                                
  • 类的继承
                                    朱辉辉33
java
                                    
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 
格式:public class 类名（子类）extends 类名（父类）{ } 
子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 
protected属性，但要使用private属性仍需通过调用。 
子类的方法可以重写，但必须和父类的返回值类
    
                                
    • 
                                
  • android 悬浮窗特效
                                    肆无忌惮_
android
                                    
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下： 
  
一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。 
  
后来想利用Dialog的dismiss动画来完成。 
  
自定义一个Dialog后，在styl
    
                                
    • 
                                
  • hadoop伪分布式搭建
                                    林鹤霄
hadoop
                                    
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
    
                                
    • 
                                
  • gdb调试命令
                                    aigo
gdb
                                    
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362 
  
一、GDB常用命令简介 
     r run 运行.程序还没有运行前使用   c             cuntinue 
    
                                
    • 
                                
  • Socket编程的HelloWorld实例
                                    alleni123
socket
                                    
    public class Client
{
	
	
	public static void main(String[] args)
	{	
		Client c=new Client();
	 	c.receiveMessage();
	}
	
	public void receiveMessage(){
		Socket s=null;
		
		BufferedRea
    
                                
    • 
                                
  • 线程同步和异步
                                    百合不是茶
线程同步异步
                                    
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。  所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法  
  
多线程和异步:多线程可以做不同的事情,涉及到线程通知 
  
  
&
    
                                
    • 
                                
  • JSP中文乱码分析
                                    bijian1013
javajsp中文乱码
                                    
            在JSP的开发过程中，经常出现中文乱码的问题。 
        首先了解一下Java中文问题的由来： 
        Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
    
                                
    • 
                                
  • js实现页面跳转重定向的几种方式
                                    bijian1013
JavaScript重定向
                                    
            js实现页面跳转重定向有如下几种方式： 
一.window.location.href 
<script language="javascript"type="text/javascript"> 
	window.location.href="http://www.baidu.c
    
                                
    • 
                                
  • 【Struts2三】Struts2 Action转发类型
                                    bit1129
struts2
                                    
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下 
  
<!DOCTYPE struts PUBLIC  
        "-//Apache Software Foundation//DTD Struts Configurat
    
                                
    • 
                                
  • 【HBase十一】Java API操作HBase
                                    bit1129
hbase
                                    
    Admin类的主要方法注释： 
  1. 创建表 
 /**
   * Creates a new table. Synchronous operation.
   *
   * @param desc table descriptor for table
   * @throws IllegalArgumentException if the table name is res
    
                                
    • 
                                
  • nginx gzip
                                    ronin47
nginx gzip
                                    
    Nginx GZip 压缩  
Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 
常用配置片段如下：  
gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
    
                                
    • 
                                
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交
                                    bylijinnan
java
                                    
    

public class LinkListTest {

	/**
	 * we deal with two main missions:
	 * 
	 * A.
	 * 1.we create two joined-List(both have no loop)
	 * 2.whether list1 and list2 join
	 * 3.print the join
    
                                
    • 
                                
  • Spring源码学习-JdbcTemplate batchUpdate批量操作
                                    bylijinnan
javaspring
                                    
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 
 
JDBC的batch操作： 
 
 


String sql = "INSERT INTO CUSTOMER " +
				  "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
				
    
                                
    • 
                                
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展
                                    comsci
工作流
                                    
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出......... 
 
    竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
    
                                
    • 
                                
  • base64编码和url编码
                                    cuityang
base64url
                                    
    import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.io.StringWriter; 
import java.io.UnsupportedEncodingException; 
    
                                
    • 
                                
  • web应用集群Session保持
                                    dalan_123
session
                                    
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
    
                                
    • 
                                
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式']
                                    dcj3sjt126com
数据库
                                    
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
    
                                
    • 
                                
  • solr StatsComponent（聚合统计）
                                    eksliang
solr聚合查询solr stats
                                    
    StatsComponent 
转载请出自出处：http://eksliang.iteye.com/blog/2169134 
http://eksliang.iteye.com/ 一、概述 
       Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能 
  二、参数
    
                                
    • 
                                
  • 百度一道面试题
                                    greemranqq
位运算百度面试寻找奇数算法bitmap 算法
                                    
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字. 
  
我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。 
  
还有人觉得应该用算法xxx,我是没想到用啥算法好...！ 
  
还有觉得应该先排序... 
  
还有觉
    
                                
    • 
                                
  • Spring之在开发中使用SpringJDBC
                                    ihuning
spring
                                    
      
在实际开发中使用SpringJDBC有两种方式： 
  
1. 在Dao中添加属性JdbcTemplate并用Spring注入； 
    JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
    
                                
    • 
                                
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节
                                    justjavac
json
                                    
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
    
                                
    • 
                                
  • 网站项目建设流程概述
                                    macroli
工作
                                    
    一.概念 
网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 
二.需求分析 
项目立项 
　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 
客户的需求说明书 
　　第一步是需
    
                                
    • 
                                
  • AngularJs 三目运算 表达式判断
                                    qiaolevip
每天进步一点点学习永无止境众观千象AngularJS
                                    
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 
var b = "{{",
      a = "}}";
        this.startSymbol = function(a) {

    
                                
    • 
                                
  • Spark算子：统计RDD分区中的元素及数量
                                    superlxw1234
sparkspark算子Spark RDD分区元素
                                    
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量 
  
  
Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。 
  
可以利用RDD的mapPartitionsWithInd
    
                                
    • 
                                
  • Spring 3.2.x将于2016年12月31日停止支持
                                    wiselyman
Spring 3
                                    
          
        Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。 
  
       请大家及时准备及时升级到Spring 
    
                                
    • 
                                
  • fis纯前端解决方案fis-pure
                                    zccst
JavaScript
                                    
    作者：zccst 
 
FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 
 
 
1，fis-pure的安装 
$ fis install -g fis-pure 
$ pure -v 
0.1.4 
 
 
2，下载demo到本地 
git clone https://github.com/hefangshi/f
    
                                
    •