首先，说明一下功能需求，平时定义一个接口，就要使用implements关键字来实现接口。那么，当不使用此关键字的时候，是否也能使相关接口也能够绑定实现类呢？

答案是肯定的。

此篇文章的主要功能有两个：

1）从实现原理上，更深层次的理解mybatis的映射逻辑；

2）此功能实战中可以通过配置的方式，在不同环境或者客户中执行不同的业务逻辑；

1.创建接口和实现类，但不使用implements

接口：

public interface ProductService {void getProductName(String name);
}

未实现implements关键字的实现类：

@ImplService(parentUrl = "com.example.springdragoncommon.hbl.yms.spring.mapper.service.ProductService")
public class ProductServiceImpl {public ProductServiceImpl(){System.out.println("我是构造函数！");}public void getProductName(String name){System.out.println("我是一个被代理的实现方法！");}
}

可以看到此时没有使用implements关键字，但是使用了一个@ImplService自定义注解，这里的注解就有点类似于mybaties中的<mapper namespace="">

2.创建自定义注解

这里需要两个自定义注解：

1）@ServiceScan注解

用于定义需要扫描的路径，类似于mybatis中的MapperScan功能

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import(ScanServiceImportBeanDefinitionRegistrar.class)
public @interface ServiceScan {/*** 需要扫描的实现类的路径* @return*/String[] packageScan() default {};
}

2）@ImplService注解

此注解就是指定此类实现了哪一个接口的功能。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ImplService {String parentUrl() default "";
}

3.ScanServiceImportBeanDefinitionRegistrar类

此类是ServiceScan注解中，使用@Import注解引入的类，它实现ImportBeanDefinitionRegistrar接口，

public class ScanServiceImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {List<String> packages = findPackages(importingClassMetadata);ClassPathScanner classPathScanner = new ClassPathScanner(registry);classPathScanner.addIncludeFilterCustom();classPathScanner.doScan(StringUtils.toStringArray(packages));}/*** 获取扫描注解解析的类* @param importingClassMetadata* @return*/private List<String> findPackages(AnnotationMetadata importingClassMetadata) {AnnotationAttributes annotationAttributes = AnnotationAttributes.fromMap(importingClassMetadata.getAnnotationAttributes(ServiceScan.class.getName()));List<String> packages = new ArrayList<>();for (String className :annotationAttributes.getStringArray("packageScan")){if (StringUtils.hasText(className)) {packages.add(className);}}return packages;}
}

此处主要的类是ClassPathScanner类，它本身实现了ClassPathBeanDefinitionScanner类，重写了doScan方法和addIncludeFilter方法，

public class ClassPathScanner extends ClassPathBeanDefinitionScanner {private BeanDefinitionRegistry registry;private ScanClassBeanFactory scanClassBeanFactory = new ScanClassBeanFactory();public ClassPathScanner(BeanDefinitionRegistry registry) {super(registry);this.registry=registry;}@Overrideprotected Set<BeanDefinitionHolder> doScan(String... basePackages) {Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);if (beanDefinitionHolders == null || beanDefinitionHolders.isEmpty()){logger.error("not find target class");}else {this.postProcessBeanDefinition(beanDefinitionHolders);}return beanDefinitionHolders;}protected void postProcessBeanDefinition(Set<BeanDefinitionHolder> beanDefinitionHolders){if (beanDefinitionHolders ==null || beanDefinitionHolders.isEmpty()){return;}//此处为了防止多实现，防止注入异常，默认第一个加载Map<String,String> removeMap = new ConcurrentHashMap<>();beanDefinitionHolders.stream().forEach(p->{ScannedGenericBeanDefinition beanDefinition = (ScannedGenericBeanDefinition) p.getBeanDefinition();String parentUrl = beanDefinition.getMetadata().getAnnotations().get(ImplService.class).getString("parentUrl");if (!StringUtils.hasText(removeMap.get(parentUrl))){String targetClassName = beanDefinition.getMetadata().getClassName();try {beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0,Class.forName(parentUrl));beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(1,Class.forName(targetClassName));beanDefinition.setBeanClass(this.scanClassBeanFactory.getClass());} catch (ClassNotFoundException e) {e.printStackTrace();}removeMap.put(parentUrl,targetClassName);}});}public void addIncludeFilterCustom() {//添加扫描拦截器判断addIncludeFilter(new TypeFilter() {@Overridepublic boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {return true;}});}
}

1）doScan方法

调用了父类的doScan方法，即获取当前basePackages下的所有实现类的BeanDefinitionHolder，

2）postProcessBeanDefinition方法

此方法为关键方法：

它首先获取了实现类的bean定义，即上面ProductServiceImpl类的bean定义；

然后获取到了要实现的接口，然后通过bean定义提供的操作，将ProductServiceImpl的bean定义转换成了ScanClassBeanFactory的bean定义，即一个实现类对应一个ScanClassBeanFactory的bean定义；

在此过程中，就可以进行不同环境或客户提取不同的实现类，此处没有实现，可以直接配置一个环境变量，类似于key-value这种参数，不同环境下取什么实现类，然后在此处判断处理即可；

3）addIncludeFilterCustom方法

此处添加的是类生成定义时候使用的过滤器，不重写的话可能存在问题，生成不了自己需要的bean定义

4.ScanClassBeanFactory类

public class ScanClassBeanFactory<T> implements FactoryBean {private Class<T> targetClass;private Class<T> targetImplClassName;public ScanClassBeanFactory(){}public ScanClassBeanFactory(Class<T> targetClass, Class<T> targetImplClassName) {this.targetClass = targetClass;this.targetImplClassName = targetImplClassName;}@Overridepublic Object getObject() throws Exception {Object object = targetImplClassName.newInstance();BeanScanInvocationHandler beanScanInvocationHandler = new BeanScanInvocationHandler(object,targetClass);return  Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class[]{targetClass}, beanScanInvocationHandler);}@Overridepublic Class<?> getObjectType() {return this.targetClass;}
}

它实现了FactoryBean接口，所以会调用一次getObject方法，此方法使用了代理方式，即给接口代理实际的实现类；

5.BeanScanInvocationHandler类

public class BeanScanInvocationHandler implements InvocationHandler {private Object target;private Class<?> interfaces;private Map<Method,Method> methodMap;public BeanScanInvocationHandler(Object target,Class<?> interfaces){this.target = target;this.interfaces = interfaces;this.methodMap = getMethods(target.getClass(),interfaces);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Method targetMethod = methodMap.get(method);return targetMethod.invoke(target,args);}private Map<Method, Method> getMethods(Class<?> delegate, Class<?>... interfaces){Map<Method, Method> map;List<Method> methods = new ArrayList<>();for (Class<?> sourceClass : interfaces) {methods.addAll(getMethods(sourceClass));}map = new HashMap<>(methods.size(), 1.0f);for (Method method : methods) {try {map.put(method, delegate.getMethod(method.getName(), method.getParameterTypes()));} catch (NoSuchMethodException ignore) {throw new RuntimeException(ignore);}}return map;}private Collection<? extends Method> getMethods(Class<?> sourceClass) {Set<Method> result = new HashSet<>();Class<?> searchType = sourceClass;while (searchType != null && searchType != Object.class) {result.addAll(filterPublicMethods(Arrays.asList(sourceClass.getDeclaredMethods())));if (sourceClass.isInterface()) {Class<?>[] interfaces = sourceClass.getInterfaces();for (Class<?> interfaceClass : interfaces) {result.addAll(getMethods(interfaceClass));}searchType = null;} else {searchType = searchType.getSuperclass();}}return result;}private Collection<? extends Method> filterPublicMethods(List<Method> methods) {List<Method> result = new ArrayList<>(methods.size());for (Method method : methods) {if (Modifier.isPublic(method.getModifiers())) {result.add(method);}}return result;}
}

此方法主要先通过接口获取其所有的类信息，然后在通过代理的实现调用实现类的对应方法；

到此，功能代码结束，运行一下看一下效果

此处使用了postman调用，直接注入接口调用即可；代码很简单就不在写出来了。