Spring-mybatis结合的底层原理

已于 2023-07-29 18:41:10 修改
阅读量520 收藏 1
点赞数
文章标签： spring mybatis java
于 2023-07-29 16:51:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nickel369/article/details/131979788
版权

1.项目前期准备

1.1 导入maven jar包

 <dependencies>
    <!-- spring依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- spring事务依赖 -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.2.5.RELEASE</version>
    </dependency>
    <!-- mybatis依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.1</version>
    </dependency>
    <!-- mybatis和spring集成依赖 -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.1</version>
    </dependency>
    <!-- mysql驱动 -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.9</version>
    </dependency>
    <!-- 阿里的连接池 -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>
    <!-- 单元测试 -->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

1.2项目相关的文件夹

在这里插入图片描述

说明：

  1. mapper文件夹：存所有的sql语句的接口
  2. service文件夹：存所有具体的实现的方法
  3. spring-mybatis文件夹：存所有整合spring和mybatis的文件
  4. resources文件夹存所有的资源文件

1.2.1 UserMapper.java文件

package com.nq.mapper;


import org.apache.ibatis.annotations.Select;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 0:24
 */
public interface UserMapper {

    @Select("select 'user'")
    String selectById();
}

1.2.2 AppConfig.java文件

package com.nq.service;

import org.springframework.context.annotation.ComponentScan;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
public class AppConfig {
}

1.2.3 UserService.java文件

package com.nq.service;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:45
 */
@Component
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public void test(){
       System.out.println(userMapper.selectById());
    }

}

1.2.4 mybatis.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
  <environments default="development">
    <environment id="development">
      <!-- 使用jdbc事务管理 -->
      <transactionManager type="JDBC"/>
      <!-- 数据库连接池 -->
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url"
                  value="jdbc:mysql://127.0.0.1:3306/test?characterEncoding=utf-8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
      </dataSource>
    </environment>
  </environments>
</configuration>

1.2.5 Test.java文件

package com.nq.service;


import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.io.IOException;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/27 23:48
 */
public class Test {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
        context.register(AppConfig.class);
        context.refresh();

        UserService userService=(UserService)context.getBean("userService");
        userService.test();
    }
}

说明：由于UserMapper是接口类型，不能被spring加载，所以spring加载的时候这里就要解决接口不能够被加载的情况，其二；由于UserMapper是执行sql语句，所有需要Mybatis生成UserMapper代理对象注入到UserMapper类型当中。
在这里插入图片描述

2.手写spring-mybatis执行过程

2.1 NickelFactoryBean.java文件

package com.nq.mybatis.spring;

import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 16:00
 */
@Component
public class NickelFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        Object proxyInstance = Proxy.newProxyInstance(NickelFactoryBean.class.getClassLoader(), new Class[]{UserMapper.class}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return null;
            }
        });
        return proxyInstance;
    }

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

说明：这里让UserMapper接口成为一个bean对象，这样程序就不会报错了
在这里插入图片描述
说明：这里确实让UserMapper成为一个bean对象了，但是这里会有一个问题，假如我们建立一个OrderMappe文件的话，这里不能识别OrderMapper对象

2.2建立OrderMapper对象和UserService对象

1.OrderMapper.java对象

package com.nq.mapper;


import org.apache.ibatis.annotations.Select;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 0:24
 */
public interface OrderMapper {

    @Select("select 'order'")
    String selectById();
}

2.UserService.java对象修改

package com.nq.service;
import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:45
 */
@Component
public class UserService {

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private OrderMapper orderMapper;

    public void test(){
       System.out.println(userMapper.selectById());
        System.out.println(orderMapper.selectById());
    }

}

3.测试结果

在这里插入图片描述
说明：无法读取到OrderMapper对象

2.3让每一个mapper文件都成为bean对象

1.修改NickelFactoryBean.java文件，这里可以建立一个外部对象的形式，对所有的接口进行赋值

package com.nq.mybatis.spring;

import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;

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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 16:00
 */
public class NickelFactoryBean implements FactoryBean {

    private Class mapperInterface;

    public NickelFactoryBean(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Override
    public Object getObject() throws Exception {
        Object proxyInstance = Proxy.newProxyInstance(NickelFactoryBean.class.getClassLoader(), new Class[]{mapperInterface}, new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName());
                return null;
            }
        });
        return proxyInstance;
    }

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

注意：这里需要去掉@Component注解，不然有这个注解spring将会加载一次，这和多个mapper去使用相违背。

2.Test方法中指定对对象成为bean对象

package com.nq.service;


import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import com.nq.mybatis.spring.NickelFactoryBean;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.io.IOException;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/27 23:48
 */
public class Test {
    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext();
        context.register(AppConfig.class);

        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(NickelFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
        context.registerBeanDefinition("userMapper",beanDefinition);

        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(NickelFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
        context.registerBeanDefinition("orderMapper",beanDefinition1);


        context.refresh();

        UserService userService=(UserService)context.getBean("userService");
        userService.test();
    }
}

在这里插入图片描述

3.Test结果显示

在这里插入图片描述
说明；这里我们把每一个mapper接口创建为bean的形式，但是这里有一个问题，假如出现第三mapper文件，我们在这里需要又去添加一个，思考这里有什么方式去注册bean呢

2.4NickelBeanDefinitionRegistryPostProcess.java文件通过继承BeanDefinitionRegistryPostProcessor去注册对应的接口

package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:17
 */
@Component
public class NickelBeanDefinitionRegistryPostProcess implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(NickelFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
        registry.registerBeanDefinition("userMapper",beanDefinition);

        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(NickelFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
        registry.registerBeanDefinition("orderMapper",beanDefinition1);

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

说明；通过这种获取方式，依然没有解决新加mapper文件的时候，需要增加修改代码的形式，所以这里我们需要通过spring扫描的方式去修改mapper文件的动态获取

2.5我们通过提供注解的形式，得到需要扫描的路径，提供NickelMapperScan注解

package com.nq.mybatis.spring;

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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:24
 */
@Retention(RetentionPolicy.RUNTIME)//运行时
@Target(ElementType.TYPE)//注解只能写在类上面
public @interface NickelMapperScan {
    String value();
}

在这里插入图片描述

2.6ImportBeanDefinitionRegistrar实现接口的方式我们也能够进行注册

2.6.1修改NickelBeanDefinitionRegistryPostProcess文件

package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:17
 */
//@Component
public class NickelBeanDefinitionRegistryPostProcess implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
//        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//        beanDefinition.setBeanClass(NickelFactoryBean.class);
//        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
//        registry.registerBeanDefinition("userMapper",beanDefinition);
//
//        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
//        beanDefinition1.setBeanClass(NickelFactoryBean.class);
//        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
//        registry.registerBeanDefinition("orderMapper",beanDefinition1);

    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

    }
}

2.6.2创建NickelImportBeanDefinitionRegisty.java实现接口ImportBeanDefinitionRegistrar

package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:32
 */
public class NickelImportBeanDefinitionRegisty implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(NickelFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
        registry.registerBeanDefinition("userMapper",beanDefinition);

        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(NickelFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
        registry.registerBeanDefinition("orderMapper",beanDefinition1);
     }
}

2.6.3这里我们需要NickelImportBeanDefinitionRegisty生效，需要在AppConfig中导入

package com.nq.service;

import com.nq.mybatis.spring.NickelImportBeanDefinitionRegisty;
import com.nq.mybatis.spring.NickelMapperScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@NickelMapperScan("com.nq.mapper")
@Import(NickelImportBeanDefinitionRegisty.class)
public class AppConfig {
}

2.6.4测试运行效果

在这里插入图片描述

2.7获取扫描路径

2.7.1把注解移动到扫描类上

1.修改AppConfig文件
package com.nq.service;

import com.nq.mybatis.spring.NickelImportBeanDefinitionRegisty;
import com.nq.mybatis.spring.NickelMapperScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@NickelMapperScan("com.nq.mapper")
public class AppConfig {
}
2.修改NickelMapperScan文件
package com.nq.mybatis.spring;

import org.springframework.context.annotation.Import;

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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:24
 */
@Retention(RetentionPolicy.RUNTIME)//运行时
@Target(ElementType.TYPE)//注解只能写在类上面
@Import(NickelImportBeanDefinitionRegisty.class)
public @interface NickelMapperScan {
    String value();
}
3在NickelImportBeanDefinitionRegisty获取扫描的路径
package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:32
 */
public class NickelImportBeanDefinitionRegisty implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //获取扫描路径
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(NickelMapperScan.class.getName());
        String path = (String)annotationAttributes.get("value");
        System.out.println(path);

        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(NickelFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
        registry.registerBeanDefinition("userMapper",beanDefinition);

        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(NickelFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
        registry.registerBeanDefinition("orderMapper",beanDefinition1);
     }
}

在这里插入图片描述
说明：打印结果如下

4.通过spring的扫描逻辑获取扫描路径
1.创建类NickelClassPathBeanDefinitionScan继承spring扫描类ClassPathBeanDefinitionScanner
package com.nq.mybatis.spring;

import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 14:31
 */
public class NickelClassPathBeanDefinitionScan extends ClassPathBeanDefinitionScanner {

    public NickelClassPathBeanDefinitionScan(BeanDefinitionRegistry registry) {
        super(registry);
    }
}
2.NickelImportBeanDefinitionRegisty获取NickelClassPathBeanDefinitionScan得到扫描类
package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:32
 */
public class NickelImportBeanDefinitionRegisty implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //获取扫描路径
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(NickelMapperScan.class.getName());
        String path = (String)annotationAttributes.get("value");
        System.out.println(path);

        NickelClassPathBeanDefinitionScan nickelClassPathBeanDefinitionScan=new NickelClassPathBeanDefinitionScan(registry);
        nickelClassPathBeanDefinitionScan.scan(path);

        AbstractBeanDefinition beanDefinition= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(NickelFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);//userMapper  UserMapper代理对象
        registry.registerBeanDefinition("userMapper",beanDefinition);

        AbstractBeanDefinition beanDefinition1= BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(NickelFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);//orderMapper  OrderMapper代理对象
        registry.registerBeanDefinition("orderMapper",beanDefinition1);
     }
}

在这里插入图片描述
说明：由于spring扫描方法只能获取扫描类，而不能获取扫描接口。

5.NickelClassPathBeanDefinitionScan通过重写isCandidateComponent方法修饰，实现只能扫描接口
package com.nq.mybatis.spring;

import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;
import java.util.Set;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 14:31
 */
public class NickelClassPathBeanDefinitionScan extends ClassPathBeanDefinitionScanner {

    //注册对象
    public NickelClassPathBeanDefinitionScan(BeanDefinitionRegistry registry) {
        super(registry);
    }

    /**
     * 获取扫描类是否有值
     * @param basePackages
     * @return
     */
    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        return beanDefinitionHolders;
    }

    /**
     * 判断是否是接口
     * @param beanDefinition
     * @return
     */
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
       return beanDefinition.getMetadata().isInterface();
    }
}

在这里插入图片描述
说明：由于spring扫描只会扫描includeFilters里面的类，这里的类指的是类上面加了@Component类才会被扫描到。

6.在NickelClassPathBeanDefinitionScan时候，重写isCandidateComponent(MetadataReader metadataReader)方法，让方法都返回true
1.重写isCandidateComponent方法
package com.nq.mybatis.spring;

import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;
import java.util.Set;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 14:31
 */
public class NickelClassPathBeanDefinitionScan extends ClassPathBeanDefinitionScanner {

    //注册对象
    public NickelClassPathBeanDefinitionScan(BeanDefinitionRegistry registry) {
        super(registry);
    }

    /**
     * 获取扫描类是否有值
     * @param basePackages
     * @return
     */
    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        return beanDefinitionHolders;
    }

    /**
     * 判断是否是接口
     * @param beanDefinition
     * @return
     */
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
       return beanDefinition.getMetadata().isInterface();
    }

    /**
     * 重新是否包含的接口
     * @param metadataReader
     * @return
     * @throws IOException
     */
    @Override
    protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        return true;
    }
}

在这里插入图片描述

2.修改NickelImportBeanDefinitionRegisty方法
package com.nq.mybatis.spring;

import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.Map;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 17:32
 */
public class NickelImportBeanDefinitionRegisty implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        //获取扫描路径
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(NickelMapperScan.class.getName());
        String path = (String)annotationAttributes.get("value");
        System.out.println(path);

        NickelClassPathBeanDefinitionScan scanner=new NickelClassPathBeanDefinitionScan(registry);
        scanner.scan(path);
     }
}
3.修改NickelClassPathBeanDefinitionScan让方法的类都属于NickelFactoryBean对象
package com.nq.mybatis.spring;

import org.springframework.beans.factory.annotation.AnnotatedBeanDefinition;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.core.type.classreading.MetadataReader;

import java.io.IOException;
import java.util.Set;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/29 14:31
 */
public class NickelClassPathBeanDefinitionScan extends ClassPathBeanDefinitionScanner {

    //注册对象
    public NickelClassPathBeanDefinitionScan(BeanDefinitionRegistry registry) {
        super(registry);
    }

    /**
     * 获取扫描类是否有值
     * @param basePackages
     * @return
     */
    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
            BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            beanDefinition.setBeanClassName(NickelFactoryBean.class.getName());
        }
        return beanDefinitionHolders;
    }

    /**
     * 判断是否是接口
     * @param beanDefinition
     * @return
     */
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
       return beanDefinition.getMetadata().isInterface();
    }

    /**
     * 重新是否包含的接口
     * @param metadataReader
     * @return
     * @throws IOException
     */
    @Override
    protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        return true;
    }
}

在这里插入图片描述

4.增加MemberMapper.java接口
package com.nq.mapper;


import org.apache.ibatis.annotations.Select;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 0:24
 */
public interface MemberMapper {

    @Select("select 'user'")
    String selectById();
}
5.修改UserService.java
package com.nq.service;
import com.nq.mapper.MemberMapper;
import com.nq.mapper.OrderMapper;
import com.nq.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:45
 */
@Component
public class UserService {

    @Autowired
    private UserMapper userMapper;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private MemberMapper memberMapper;

    public void test(){
        System.out.println(userMapper.selectById());
        System.out.println(orderMapper.selectById());
        System.out.println(memberMapper.selectById());
    }

}
6.打印结果显示

结果显示
在这里插入图片描述

7.修改NickelFactoryBean代理，使得代理对象为mybatis
1.修改NickelFactoryBean对象
package com.nq.mybatis.spring;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.annotation.Autowired;

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

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 16:00
 */
public class NickelFactoryBean implements FactoryBean {

    private Class mapperInterface;

    private SqlSession sqlSession;

    public NickelFactoryBean(Class mapperInterface) {
        this.mapperInterface = mapperInterface;
    }

    @Autowired
    public void setSqlSession(SqlSessionFactory sqlSessionFactory) {
        sqlSessionFactory.getConfiguration().addMapper(mapperInterface);
        this.sqlSession = sqlSessionFactory.openSession();
    }

    @Override
    public Object getObject() throws Exception {
        return sqlSession.getMapper(mapperInterface);
    }

    @Override
    public Class<?> getObjectType() {
        return mapperInterface;
    }
}
2.修改AppConfig配置启动类
package com.nq.service;

import com.nq.mybatis.spring.NickelImportBeanDefinitionRegisty;
import com.nq.mybatis.spring.NickelMapperScan;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;

import java.io.IOException;
import java.io.InputStream;

/**
 * @author Nickel
 * @version 1.0
 * @date 2023/7/28 14:59
 */
@ComponentScan("com.nq")
@NickelMapperScan("com.nq.mapper")
public class AppConfig {

    @Bean
    public SqlSessionFactory  sqlSessionFactory() throws IOException {
          InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          return sqlSessionFactory;
    }
}

在这里插入图片描述

代码路径：
https://gitee.com/nickel369369/spring-mybatis/mirrors#/

nickel369
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
mybatis-spring-1.3.1.jar下载
05-24
下面将详细介绍MyBatis-Spring的主要功能、工作原理以及如何与MyBatis-3.4.4等版本配合使用。 MyBatis-Spring的主要功能： 1. **自动扫描与配置**：MyBatis-Spring能够自动扫描项目中的Mapper接口，并根据这些接口...
mybatis-spring-1.3.0.jar 下载
11-14
在Java开发领域，MyBatis和Spring框架的结合使用是常见的实践，它们的整合使得数据访问层的构建更为便捷和灵活。本篇文章将围绕"mybatis-spring-1.3.0.jar"这一组件展开，详细讲解其在实际项目中的作用、功能以及...
Spring源码之整合Mybatis底层实现
奔跑的蜗牛_Kieasr
05-28 706
目录 1. Spring整合Mybatis底层源码 2.SqlSessionTemplate类的作用 3. Mybatis一级缓存失效问题 1. Spring整合Mybatis底层源码 Mybatis框架可以单独使用，需要用到Mybatis所提供的一些类构造出对应的Mapper对象，然后就能使用Mybatis框架提供的功能，我们先看一个Demo： @Test public void testMybatis() throws IOException { //...
Spring整合Mybatis底层原理
qq_45065241的博客
06-04 430
Spring整合Mybatis底层原理 前言： 想必学习过Spring框架的小伙伴，知道在Spring项目中在Controller类中获取Service层的对象，我们只需在Controller类中运用@Autowired注解将Service层的对象注入进来即可，但是Service层的我们基本都是访问数据库的接口，都是运用mybatis框架去访问数据库。那么这两个框架本身是如何联系起来的？本文主要介绍Spring整合Mybatis的核心底层原理、@MapperScan注解的底层工作原理、MapperSca
spring整合mybatis原理
m0_73671382的博客
04-10 809
我们先来实现MyBatis和Spring的整合操作。
Spring 整合 Mybatis 原理
SuZhan0711
06-21 1456
在 Mybatis 中，我们可以使用一个接口去定义要执行 sql，简化代码如下：定义一个接口，@Select 表示要执行查询 sql 语句。 以下为执行 sql 代码： Mybatis的目的是：使得程序员能够以调用方法的方式执行某个指定的 sql，将执行 sql 的底层逻辑进行了封装。当调用 SqlSession 的 getMapper 方法时，会对传入的接口生成一个代理对象，而程序要真正用到的就是这个代理对象，在调用代理对象的方法时，Mybatis 会取出该方法所对应的 sql 语句，然后利用JDBC 去
MyBatis 与 Spring 整合原理分析
大鹏的博客
08-10 1640
我们常常将 Spring 与 MyBatis 结合在一起使用，由于篇幅问题，上篇《MyBatis 快速整合 Spring》仅介绍了将 MyBatis 整合到 Spring 的方式，这篇在上篇的基础上总结出几个问题，并尝试通过分析其底层源码进行回答。
【Spring事物三千问】Spring的事务管理与MyBatis事物管理结合的原理
老王的专栏
02-28 1313
spring-tx 是一套事务管理框架。Mybatis 是一个 ORM 框架，它会操作 DB 连接来执行 sql，所以，也会涉及到事务的处理。在 MyBatis 中，是通过 SqlSession 来执行 sql 的，也是通过它来管理事务的。默认情况下，MyBatis 是开启事务的，即:那么，spring-tx 的事务管理是如何与 mybatis 的事务管理进行整合的呢？
Spring整合Mybatis原理
wuliyouMaozhi的博客
07-22 520
Spring整合Mybatis原理
spring+springmvc+mybatis原理总结（附流程图）
不积硅步，无以至千里
03-22 1221
本文主要分析spring、springmvc和mybatis架构原理，绘制多张流程图，便于理解ssm框架底层设计原理。
SpringBoot结合MyBatis 【超详细】
热门推荐
m0_65563175的博客
10-16 9万+
Spring Boot与MyBatis框架集合实践。内置MyBatis大部分使用技巧，而Spring Boot起到个快速入门的效果。其中MyBatis内容涉及到业务层与数据访问层的传参知识、企业常用的动态SQL拼接、高级映射及延迟加载、以及缓存机制、最后包括PageHelper分页插件
mybatis-4 mybatis与spring结合使用及原理解析
08-26
将 MyBatis 与 Spring 结合使用，可以充分利用两者的优点，实现数据库操作的便捷性和应用的灵活性。 在集成 MyBatis 和 Spring 的过程中，主要涉及以下几个关键点： 1. **依赖管理**：在 Maven 项目中，我们需要...
MyBatis和Spring结合的案例
11-22
接下来，我们将深入探讨Spring与MyBatis结合的案例及其背后的原理和实践。 1. **Spring与MyBatis的整合** - **Spring的IoC容器**：Spring的IoC（Inversion of Control，控制反转）容器负责管理对象的生命周期和...
mybatis-Spring整合jar包
04-18
这个整合jar包包含了MyBatis和Spring的基本组件，使得开发人员能够方便地将两者结合在一起，实现数据访问层的高效管理。 MyBatis是一个轻量级的SQL映射框架，它允许开发者编写SQL语句，同时提供了Java对象和SQL查询...
【计算机毕业设计】基于Springboot的B2B平台医疗病历交互系统【源码+lw+部署文档】
最新发布
06-30 517
目录1.1 选题的依据及意义1.2 国内外现状研究1.3 研究目的 第2章 设计技术与开发环境2.1 相关技术介绍 2.1.1 B/S模式分析2.1.2 mysql简介2.1.3 Spring Boot 简介2.2 开发环境介绍 2.2.1 eclipse简介2.2.2 Tomcat简介第3章 需求分析与可行性分析3.1 需求分析3.1.1 应用需求分析3.1.2 运行需求分析3.1.3 其他需求分析3.2 数据流程分析3.2.1 系统操作流程3.2.2 数据增加流程3.2.3 数据修改流程3.2.4
SpringBoot整合Minio
上善若泪
06-30 358
文章目录1 Minio1.1 概述1.2 应用场景1.3 Minio实现分片上传的主要步骤1.4 Centos7安装Minio1.5 搭建springboot 环境1.5.1 pom.xml1.5.2 创建容器桶1.5.3 编写配置文件1.5.4 常量类1.5.5 创建Minio的配置类1.5.5 创建Minio的工具类1.5.6 创建Ajax请求工具类1.5.7 创建Minio文件操作接口层 1 Minio 1.1 概述 Minio 官网地址：https://min.io/ 文档地址：https://do
在Spring MVC框架中，如何处理HTTP请求和响应？
2301_79375313的博客
06-28 356
在整个过程中，Spring MVC提供了许多扩展点和配置选项，允许开发者根据需求进行定制和优化。例如，可以通过拦截器（Interceptor）来拦截和处理请求和响应，通过消息转换器（Message Converter）来定制请求和响应体的格式等。在Spring MVC框架中，HTTP请求和响应的处理是通过一系列组件和流程来完成的。
SpringBoot 参数校验
Mazai-Liu的博客
06-29 521
已有的注解不能满足校验要求，需要自定义注解首先定义自定义注解// 指定校验规则// 校验失败后的提示信息String message() default "只能是“已发布”或者“草稿”";// 指定分组Class<?// 获取附加信息Class<?定义处理规则@Override// 提供校验规则return "已发布".equals(s) || "草稿".equals(s);使用方式和其他注解一致。
spring -mybatis.xml
05-16
Spring-MyBatis整合是一种常见的开发方式，其中spring-mybatis.xml文件是用来配置Spring和MyBatis框架集成的配置文件。在这个文件中，我们会定义数据源、事务管理器、扫描Mapper接口等配置信息。同时，我们还需要将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值