转载

Mybatis是如何跟Spring整合的

写在前面

Mybatis官网中,有这么一节专门介绍如何注入一个mapper

Mybatis是如何跟Spring整合的

对于单个mapper,有两种方式可以注入,分别是xml和注解

Mybatis是如何跟Spring整合的

其中,xml这种方式耐人寻味。

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

不妨我们今天就手写一个小框架,来实现mapper注入的功能。

动态代理

我们都知道,mybatis通过动态代理来实现将interface接口转为具体的类,来执行相应的mapper。具体是怎样做的呢?

SqlSession.java

/**
   * Retrieves a mapper.
   * @param <T> the mapper type
   * @param type Mapper interface class
   * @return a mapper bound to this SqlSession
   */
  <T> T getMapper(Class<T> type);

一路追查下去

DefaultSqlSession.java

@Override
  public <T> T getMapper(Class<T> type) {
    return configuration.getMapper(type, this);
  }

Configuration.java

public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
    return mapperRegistry.getMapper(type, sqlSession);
  }

MapperProxyFactory.java

@SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }

  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }

这时我们可以看到真身了,mybatis正是使用了JDK的动态代理实现了对mapper的代理。那JDK的动态代理是怎么回事呢?

MapperProxy实现了InvocationHandler接口,需要实现invoke方法。这里我们来探究一下,为什么JDK的动态代理,实现InvocationHandler接口就可以了?

先来一个接口

public interface IHello {
    void sayHello();
}

被代理对象

public class RealSubject implements IHello {
    @Override
    public void sayHello() {
        System.out.println("我是被逼说hello的");
    }
}

InvocationHandler增强日志

public class MyHandler implements InvocationHandler {
    private Object target;

    public MyHandler(Object subject) {
        this.target = subject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("前置日志");
        Object res = method.invoke(target, args);
        System.out.println("后置日志");
        return res;
    }
}

在client中跑一下

public static void main(String[] args) throws IOException {
        RealSubject realSubject = new RealSubject();
        MyHandler myHandler = new MyHandler(realSubject);

        IHello iHello = (IHello) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(), new Class[]{IHello.class}, myHandler);
        iHello.sayHello();
    }

得到输出

前置日志
我是被逼说hello的
后置日志

Proxy.newProxyInstance可以动态地获取一个代理对象,代理对象调用接口中的方法时,会进入InvokationHandler里的invoke方法,而我们的实现是,先打印前置日志,再调用被代理对象的方法,最后输出后置日志。这一切是怎么运转起来的呢?

这里我们需要借助ProxyGenerator,来一窥代理的真容

private static void createProxyClass() throws IOException {
        byte[] proxyBytes = ProxyGenerator.generateProxyClass("IHello$Proxy", new Class[]{IHello.class});
        Files.write(new File("YOUR_PATH/IHello$Proxy.class").toPath(), proxyBytes);
    }

这时,我们可以得到Proxy.class,这个代理对象继承了Proxy并实现了IHello接口,由于Java是单继承且已经继承自Proxy,所以JDK的动态代理是基于接口的

public final class IHello$Proxy extends Proxy implements IHello {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public IHello$Proxy(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("your.package.IHello").getMethod("sayHello");
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

我们看到sayHell()方法,好眼熟啊!这个h是父类Proxy中的 protected InvocationHandler h; 。那这个h是怎么传进来的呢?前方高能!前方高能!前方高能!

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        Objects.requireNonNull(h);

        final Class<?>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }

        /*
         * Look up or generate the designated proxy class.
         */
        Class<?> cl = getProxyClass0(loader, intfs);

        /*
         * Invoke its constructor with the designated invocation handler.
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }

            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

这里会拿到代理类的构造方法,这个构造方法的参数是constructorParams,这个constructorParams是什么呢? private static final Class<?>[] constructorParams = { InvocationHandler.class }; 那我们就可以从 IHello$Proxy 中找到这个构造函数:

public IHello$Proxy(InvocationHandler var1) throws  {
        super(var1);
    }

这个super(var1)就是

protected Proxy(InvocationHandler h) {
        Objects.requireNonNull(h);
        this.h = h;
    }

对上了有木有!有木有!!激动不激动!!!

这样,当我们使用Proxy.newInstance()获取到的代理对象调用相应方法时,就会跑到我们自己写的InvocationHandler实现类里invoke方法!我不管,我要为自己的牛逼点个赞:+1:

与Spring整合

好了,不要脸半天了,收!

我们现在可以通过一个UserMapper的接口来创建一个代理对象了,但是我们怎么把这个对象交给Spring托管呢?

注意,我们这边是 已经new好了对象了,然后交给Spring去管理 ,而不是 提供给Spring一个类,让Spring帮我们new一个对象是管理 ,这还是有本质区别的!

Spring会先使用BeanDefinition来保存Bean的信息,其中包含bean的scope、class相关信息、是否懒加载等等内容,当BeanDefinition对象创建好后,会先存入一个map。

为什么Spring不直接new呢?

直接new的话可能不符合条件,比如我们提供的interface;另外,直接new的话,提供给程序员可自由发挥的空间就小了。

这里,我们要导出Spring的一个后置处理器了

BeanFactoryPostProcessor

实现BeanFactoryPostProcessor接口,我们就可以对BeanDefinition进行处理了。

假设有A、B两个类,我们在postProcessBeanFactory获取到A这个BeanDefinition,然后将其BeanClass设置为B,然后从ApplicationContext中获取A

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        GenericBeanDefinition a = (GenericBeanDefinition) beanFactory.getBeanDefinition("a");
        a.setBeanClass(B.class);
    }
}

Spring会毫不留情地告诉我们

Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'your.package.domain.A' available
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:350)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBean(DefaultListableBeanFactory.java:341)
    at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1123)
    at com.meituan.Starter.main(Starter.java:22)

我们可以通过这个后置处理器来处理我们的动态代理类,可以似乎还是不够

FactoryBean与ImportBeanDefinitionRegistrar

BeanFactoryPostProcessor的局限是我们只能从BeanFactory中获取一个BeanDefinition,然后修改它的属性,而不能直接往里面添加一个新的BeanDefinition,这时我们要再挖掘些新玩意儿。

将new出来的对象交给Spring托管有三种常用的方法:

  1. BeanFactory.registerSingleton(String beanName, Object singletonObject);
  2. 基于@Bean,自己在方法中new出一个对象来
  3. FactoryBean!

这里我们用第三种方法

public class MyFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        return Proxy.newProxyInstance(CityMapper.class.getClassLoader(), new Class[]{CityMapper.class}, new MyInvocationHandler());
    }

    @Override
    public Class<?> getObjectType() {
        return CityMapper.class;
    }
}

这样可以解决一个mapper的注入问题,可以如果mybatis要提供一个框架,这样写可扩展性不好,这时我们可以把class作为一个参数注入进来

public class MyFactoryBean implements FactoryBean {
    private Class mapperInterface;

    public void setMapperInterface(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Override
    public Object getObject() throws Exception {
        return Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[]{mapperInterface}, new MyInvocationHandler());
    }

    @Override
    public Class<?> getObjectType() {
        return mapperInterface;
    }
}

这时我们回看mybatis官网的那个xml配置,不禁恍然大悟!把这里的MyFactoryBean替换成MapperFactoryBean不就是了嘛!

<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
  <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
  <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

那我们如何将这个MyFactoryBean交给Spring呢?

这时我们还需要写一个类,实现ImportBeanDefinitionRegistrar,这个接口可以帮我们把一个BeanDefinition放入Spring的map

public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MyFactoryBean.class);
        GenericBeanDefinition beanDefinition = (GenericBeanDefinition) builder.getBeanDefinition();
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue("your.package.dao.CityMapper");
        registry.registerBeanDefinition("xxx", beanDefinition);
    }
}

这个类我们通过一个注解引入,这时会用到@Import注解

@Retention(RetentionPolicy.RUNTIME)
@Import(MyBeanDefinitionRegistrar.class)
public @interface MyScan {
}

将这个注解放到

@ComponentScan("your.package")
@Configuration
@MyScan
public class AppConfig {
}

大功告成,撒花!

参考文档

http://mybatis.org/spring/map...

原文  https://segmentfault.com/a/1190000020385510
正文到此结束
Loading...