在《大话设计模式》这本书中，我会听到这个字眼“对接口编程”，而在文中的类图中，会提出这样一个疑问？为什么有的用的是：接口？有的用的是抽象类呢？
    本文主要介绍以下内容：接口、抽象类。
    文章的最后，会给出软考下午设计模式题中的一些做题技巧


• 什么是接口？

    接口是包含一组虚方法的抽象类型，其中每一种方法都有其名称、参数和返回值。接口方法不能包含任何实现，CLR 允许接口可以包含事件、属性、索引器、静态方法、静态字段、静态构造函数以及常数。

    注意：一个类可以实现多个接口，当一个类继承某个接口时，它不仅要实现该接口定义的所有方法，还要实现该接口从其他接口中继承的所有方法。



• 什么是抽象类？

    抽象类提供多个派生类共享基类的公共定义，它既可以提供抽象方法，也可以提供非抽象方法。抽象类不能实例化，必须通过继承由派生类实现其抽象方法，因此对抽象类不能使用new 关键字，也不能被密封。如果派生类没有实现所有的抽象方法，则该派生类也必须声明为抽象类。



• 对比分析




• 考试秘籍
  下面从软考设计模式的做题技巧入手，提供一些参考：（以Java语言为例）
抽象类用关键字abstract声明，用extends继承。抽象类的目的是定义一个框架，规定某些类必须具有的一些共性。抽象方法：没有函数体的方法
  注意：包含抽象方法的类，一定是抽象类。
       抽象类的直接派生类必须实现其抽象方法，抽象类只能用于继承，不能用于创建对象（所谓的new）。


接口用关键字interface声明，关键字implements实现。接口用于替代多继承的概念。
  注意：直接继承了接口的类，必须实现接口中的抽象方法；间接的则可以实现，也可以不实现。


区分：
  1、接口和抽象类都不能创建对象。
  2、抽象类不能参与多继承，抽象类可以有非静态的成员变量，可以有非抽象的方法；
  3、接口可以参与多继承，所有的属性都是静态常量，所有的方法都是public方法。


• 结论
    本文基本概况了接口和抽象类的概念、异同和使用规则。但是，对于面向对象和软件设计的深入理解，还是建立在不断实践的基础上。

文章目录
通过AOP切入注解的方式对接口参数进行非空判断
1、创建注解
2、创建切入点
3、应用注解
4、注解响应

通过AOP切入注解的方式对接口参数进行非空判断

1、创建注解
package com.zyfycs.college.core.aop.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author Created by 谭健 on 2018/11/2 0002. 星期五. 9:47.
 * © All Rights Reserved.
 */


@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface HandleParams {


    /**
     * 不需要检验的参数的名称
     * 默认情况下，会检查该接口的所有参数值
     */
    String[] excludeParams() default {};


    /**
     * notNull
     * notBlank
     * 两个只会处理一个，notBlank 的优先级更高，
     * 如果notBlank 为 true 则不进行 notNull 逻辑处理，因为 notNull 是 notBlank 的子内容
     * 如果只使用 notNull 判断，则应该设置 notBlank 为 false ，notNull 为true
     */
    boolean notNull() default false;

    boolean notBlank() default true;
}


2、创建切入点

package com.zyfycs.college.core.aop;

import com.google.common.collect.Lists;
import com.zyfycs.college.core.aop.annotation.HandleParams;
import com.zyfycs.college.exception.runtime.ParamBlankException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Created by 谭健 on 2018/11/2 0002. 星期五. 9:45.
 * © All Rights Reserved.
 */


@Slf4j
@Component
@Aspect
public class AspectParamCheck {


    @Around("@annotation(com.zyfycs.college.core.aop.annotation.HandleParams)")
    public Object paramCheck(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        String[] parameterNames = signature.getParameterNames();
        Object[] args = point.getArgs();
        Class<?>[] parameterTypes = signature.getParameterTypes();
        HandleParams handleParams = signature.getMethod().getAnnotation(HandleParams.class);
        String[] excludeParams = handleParams.excludeParams();
        List<String> excludeParamList = Lists.newArrayList(excludeParams);
        String location = point.getTarget().toString() + "." + signature.getMethod().getName();
        for (int i = 0; i < args.length; i++) {
            if (handleParams.notBlank()) {
                notBlank(location, excludeParamList, parameterNames[i], args[i], parameterTypes[i].getName());
            } else if (handleParams.notNull()) {
                notNull(location, excludeParamList, parameterNames[i], args[i], parameterTypes[i].getName());
            }
        }
        return point.proceed();
    }


    private void notNull(String location, List<String> excludeParamList, String paramName, Object value, String paramType) {
        // 如果该参数不在排除范围内，则进行校验
        if (!excludeParamList.contains(paramName)) {
            if (value == null) {
                throw new ParamBlankException(location + " Error : [" + paramName + "] is Null ,Type is [" + paramType + "]");
            }
        }
    }

    private void notBlank(String location, List<String> excludeParamList, String paramName, Object value, String paramType) {
        // 如果该参数不在排除范围内，则进行校验
        if (!excludeParamList.contains(paramName)) {
            if (value == null || StringUtils.isBlank(value.toString())) {
                throw new ParamBlankException(location + " Error : [" + paramName + "] is Blank ,Type is [" + paramType + "]");
            }
        }
    }
}



3、应用注解
只需要在有参数并且需要做非空判断的接口方法上打上    @HandleParams 注解就会自动检查了

    @HandleParams
    @GetMapping("/request")
    public ApiResponse request(BigDecimal amount, Long bankCardId,String authCode,String code) {｝


4、注解响应
当注解工作后，会抛出ParamBlankException 异常

package com.zyfycs.college.exception.runtime;

import lombok.Getter;

/**
 * @author Created by 谭健 on 2018/11/2 0002. 星期五. 10:02.
 * © All Rights Reserved.
 */

@Getter
public class ParamBlankException extends RuntimeException {

    public ParamBlankException() {
    }

    public ParamBlankException(String message) {
        super(message);
    }
}



异常抛出后，由全局异常处理器处理，通过Rest 方式返回给前端

并且在控制台打印具体的错误信息
    @ExceptionHandler(ParamBlankException.class)
    @ResponseBody
    public ApiResponse resolveException(HttpServletRequest request,ParamBlankException e){
        log.error(e.getMessage());
        return new ApiResponse(ErrorEnum.PARAM_BLANK);
    }

Jmockit对接口与基类的mock

对一个类或接口使用@Capturing，那么该类的所有子类或接口所有实现都将处于mocked状态，即使是临时定义的实现或子类也会是mocked状态

接口示例：

//接口
public interface JInterface
{
    public String methodA(String para);
}
//实现
public class ImplA implements JInterface
{
    public String methodA(String para)
    {
        return "oringinal methodA " + para;
    }
}


Mock测试

@Test
public void test1(@Capturing final JInterface jInterface)//JInterface接口被mocked
{
    JInterface i = new ImplA();
    System.out.println(i.methodA("d"));//null 因为被mocked

    new NonStrictExpectations()
    {
        {
            jInterface.methodA(anyString);
            returns("first mocked impl method", "second mocked impl method");//
        }
    };

    System.out.println(i.methodA("ohad")); //record的第一个结果first mocked impl method

    //新定义的实现也将处于mocked状态
    JInterface i3 = new JInterface()
    {

        public String methodA(String para)
        {
            // TODO Auto-generated method stub
            return null;
        }
    };

    System.out.println(i3.methodA("dpfiojaoifh")); //record的第二个结果second mocked impl method
}


继承示例：

//父类
public abstract class Base
{
    abstract public String methodA();
}
//子类
public class ExtendA extends Base
{
    @Override
    public String methodA()
    {
        return "original method";
    }


Mock测试

@Test
public void test4(@Capturing final Base base)
{
    Base obj = new ExtendA();
    System.out.println(obj.methodA());//null

    new NonStrictExpectations()
    {
        {
            base.methodA();
            //这里相当于returns(Object firstValue, Object... remainingValues)
            result = "mocked method1";
            result = "mocked method2";
        }
    };

    System.out.println(obj.methodA());//mocked method1

    Base obj1 = new Base()
    {

        @Override
        public String methodA()
        {
            return null;
        }
    };

    System.out.println(obj1.methodA());//mocked method2
}

最近实现一个功能，在访问dao层方法前需要切换数据源，通过自定义注解+AOP实现：AOP中拦截被注解的方法，实现数据源切换。Dao层用mybatis实现，注解加在Mapper接口中的方法上。但是AOP无法对加了自定义注解的方法进行拦截。由此做了以下总结：
一、关于注解继承问题
对于接口，在接口中的注解无论如何都不能被继承，不论是子接口继承父接口的情况还是接口的实现类的情况，不论是对接口上还是接口中的方法上的注解，都不能，以上经过测试所得。
对于类，若注解上使用@Inherited标注，类上的注解可以被继承。 @Inherited表示该类上的注解可以被注解，与方法上的注解的继承性无关。
对于类中方法上的注解，若子类覆写了父类带注解方法，从子类无法获取到注解。子类未覆写父类带注解方法，可以通过子类获得注解。与注解是否标注@Inherited无关。
其实，注解在方法中,没有所谓继承问题,只有重写问题。如果注解在父类方法中,如果方法没有被子类重写,那么调用的是父类的方法,那么注解是存在的,如果方法被子类重写,子类方法没有注解,那么调用子类方法就获取不了注解
二、关于在接口的方法中加注解作为拦截点，拦截失败的原因：
1、AOP使用jdk动态代理的情况
接口中的注解无法被实现类继承，AOP中的切点无法匹配上实现类，所以并不会为实现类创建代理（根据是否被满足注解条件来判断是否创建代理，标红部分经过测试所得），所以我们使用的还是原始的未被代理的对象，所以就不会被拦截到了。
2、AOP使用cglib动态代理的情况
在不存在切点注解继承的情况，AOP可进行有效拦截（cglib动态代理）。但是考虑以下存在注解继承的情况
有类Parent，类Sub，Sub继承自Parent。根据注解的继承原则，切点注解在父类方法，
若Sub覆写了父类所有带注解方法，实际Sub中并未被AOP标识，所有spring并不会为Sub创建代理类，也就不会被拦截。
若Sub覆写了父类部分带注解方法，spring会为Sub创建代理类，对于覆写了父类的方法，由于注解未被继承，不会被拦截；未覆写的方法，可以被拦截。
所以，对于我遇到的问题：在mybatis中，加在Mapper接口方法上的注解无法被拦截可以做以下解释
mybatis本身会使用jdk动态代理来为我们生成一个Mapper接口的实现类，实际上我们的aop是在对这个Mapper的实现类创建代理（使用cglib代理）。由注解继承规则，该实现类的方法并不能继承接口方法上的注解，因而spring也就无法为该实现类生成代理，aop也就拦截失败。