Spring整合Mybatis Mapper接口

最新推荐文章于 2022-05-06 07:12:33 发布
最新推荐文章于 2022-05-06 07:12:33 发布
阅读量195 收藏
点赞数 1
分类专栏： java 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weianluo/article/details/115653256
版权

编程式给Spring注入Bean

方法一，通过BeanDefinition来定义

package com;

import com.config.AppConfig;
import com.model.User;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(User.class);

        applicationContext.registerBeanDefinition("user", beanDefinition);

        User user = applicationContext.getBean("user", User.class);
        System.out.println(user.getName());

    }
}

这个方法可以直接注册Bean，类似于在类上直接加@Component注解

缺点： 可以直接注入类，但是无法注入接口

 

方法二，通过FactoryBean来注入Bean

示例1， 最简单的FactoryBean使用

package com.factorybean;


import com.model.User;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.stereotype.Component;


public class WilliamFactoryBean implements FactoryBean {
    @Override
    public Object getObject() throws Exception {
        User user = new User();
        return user;
    }

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

package com;

import com.config.AppConfig;
import com.factorybean.WilliamFactoryBean;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(WilliamFactoryBean.class);

        applicationContext.registerBeanDefinition("user", beanDefinition);

        Object user = applicationContext.getBean("user"); //这个获取的是User(name=null)
        Object user1 = applicationContext.getBean("&user");  //这个获取的是com.factorybean.WilliamFactoryBean@5e9456ae
        System.out.println(user);
        System.out.println(user1);
    }
}

实例2，BeanFactory + AOP反射注册接口 - UserMapper

 

package com.factorybean;


import com.mapper.UserMapper;
import org.springframework.beans.factory.FactoryBean;

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


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

        return instance;
    }

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

 

package com.service;

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

@Component
public class UserService {
    @Autowired
    private UserMapper userMapper;

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

import com.config.AppConfig;
import com.factorybean.WilliamFactoryBean;
import com.service.UserService;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
//        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);

        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(WilliamFactoryBean.class);

        applicationContext.registerBeanDefinition("user", beanDefinition);
        applicationContext.refresh();

        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.test();
    }
}

实例3，BeanFactory + 泛型 + AOP反射注册接口 - UserMapper、OrderMapper

package com.factorybean;


import org.springframework.beans.factory.FactoryBean;

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


public class WilliamFactoryBean implements FactoryBean {

    private Class clazz;

    WilliamFactoryBean(Class clazz){
        this.clazz = clazz;
    }

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

        return instance;
    }

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

package com;

import com.config.AppConfig;
import com.factorybean.WilliamFactoryBean;
import com.mapper.OrderMapper;
import com.mapper.UserMapper;
import com.service.UserService;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);

        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(WilliamFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);
        applicationContext.registerBeanDefinition("user", beanDefinition);

        AbstractBeanDefinition beanDefinition1 = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(WilliamFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);
        applicationContext.registerBeanDefinition("user1", beanDefinition1);


        applicationContext.refresh();

        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.test();
    }
}

4， 加入 ImportBeanDefinitionRegistrar优化

package com.factorybean;

import com.mapper.OrderMapper;
import com.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;

public class WilliamImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition.setBeanClass(WilliamFactoryBean.class);
        beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(UserMapper.class);
        registry.registerBeanDefinition("user", beanDefinition);

        AbstractBeanDefinition beanDefinition1 = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
        beanDefinition1.setBeanClass(WilliamFactoryBean.class);
        beanDefinition1.getConstructorArgumentValues().addGenericArgumentValue(OrderMapper.class);
        registry.registerBeanDefinition("user1", beanDefinition1);
    }
}

package com.config;

import com.factorybean.WilliamImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Component;

@Component
@ComponentScan(basePackages = "com")
@Import(WilliamImportBeanDefinitionRegistrar.class) //加入这个import
public class AppConfig {
}
package com;

import com.config.AppConfig;
import com.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);


        applicationContext.refresh();

        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.test();
    }
}

 

5. 引入ClassPathBeanDefinitionScanner优化

 

在扫描doScan的同时，获取到beanDefinition， 此时给WilliamFactoryBean的构造函数传参，并且修改类为WilliamFactoryBean

package com.factorybean;

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 java.util.Set;

public class WilliamMapperScanner extends ClassPathBeanDefinitionScanner {
    public WilliamMapperScanner(BeanDefinitionRegistry registry) {
        super(registry);
    }

    @Override
    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Set<BeanDefinitionHolder> beanDefinitionHolders = super.doScan(basePackages);
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
            BeanDefinition beanDefinition = beanDefinitionHolder.getBeanDefinition();

            //给WilliamFactoryBean构造函数传参
            beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(beanDefinition.getBeanClassName());
            //修改beanDefinition类名
            beanDefinition.setBeanClassName(WilliamFactoryBean.class.getName());
        }
        return beanDefinitionHolders;
    }

    /**
     * 扫描接口，这里需要重写
     */
    @Override
    protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        return beanDefinition.getMetadata().isInterface();
    }
}

 

package com.factorybean;

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 java.io.IOException;

public class WilliamImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {

        //扫描路径
        String path = "com.mapper";

        WilliamMapperScanner williamMapperScanner = new WilliamMapperScanner(registry);
        williamMapperScanner.addIncludeFilter(new TypeFilter() {
            @Override
            public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
                return true;
            }
        });
        int scan = williamMapperScanner.scan(path);
        System.out.println("--------------sacn--------------" + scan);

    }
}

package com;

import com.config.AppConfig;
import com.service.UserService;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        applicationContext.register(AppConfig.class);


        applicationContext.refresh();

        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.test();
    }
}

 

 

 

基础代码

package com.config;

import com.factorybean.WilliamImportBeanDefinitionRegistrar;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Import;
import org.springframework.stereotype.Component;

@Component
@ComponentScan(basePackages = "com")
@Import(WilliamImportBeanDefinitionRegistrar.class)
public class AppConfig {
}

package com.model;

import lombok.Data;

@Data
public class User {
    private String name;
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cn</groupId>
    <artifactId>SpringCloudAlibaba</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.0.M4</version>
    </parent>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.8</version>
        </dependency>

    </dependencies>

</project>

 

马各阿牛
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring和mybatis整合(mapper代理自动扫描方式实现)
04-08
spring和mybatis框架整合，采用mapper代理自动扫描方式实现，已添加junit测试类。建议参照我的另一资源spring和mybatis整合(原始dao方式实现)对比
spring源码之模拟mybatis通过BeanDefinition注入Mapper
weixin_41011482的博客
04-14 626
话不多说，直接上代码。 public class MyImporyBeanDefinitionRegistart implements ImportBeanDefinitionRegistrar { @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //这里是模拟获取了所有的Mapper的
框架源码专题：Spring是如何集成Mybatis的？Spring怎么管理Mapper接口的动态代理
qq_1149513559的博客
10-28 994
文章目录1. Spring集成Mybatis代码示例2. Spring 如何解析Mybatis配置文件3. Spring是怎么管理Mapper接口的动态代理的 1. Spring集成Mybatis代码示例         Spring在集成Mybatis时，使用SqlSessionFactoryBean来完成Configuration的解析，代码如下： @EnableTransactionManagement @Configu
Spring 是如何整合 Mybatis 注册 Mapper 接口的？
七秒钟的记忆
06-15 1541
手写 Spring 整合 Mybatis 的 Mapper 接口扫描
MyBatis的mapper交给Spring管理源码解析
平常心
11-29 1315
阅读此篇建议在阅读springioc之后的基础上阅读，后期会将ioc过程笔记整理在csdn上 MyBatis mapper接口如何被实例化为对象？ 通过动态道理的方式： 通过MapperProxy 代理生成了代理对象mapper public class MapperProxy implements InvocationHandler, Serializable { private s...
Mybatis运用mapper代码实现和Spring的整合（一）
邱慕夏 没有比脚更长的路，没有比人更高的山
04-20 4178
实现Mybatis利用Mapper代理实现与Spring，利用容器管理SqlSession。
Spring集成MyBatis 通用Mapper以及 pagehelper分页插件
04-05
Spring集成MyBatis 通用Mapper以及 pagehelper分页插件
(代码)SpringCloud第03讲：整合MyBatis通用Mapper
01-20
(代码)SpringCloud第03讲：整合MyBatis通用Mapper
Spring+mybatis整合实例应用
01-30
项目结构图(Spring3.0.2+mybatis3.0.4)应用数据库对应的实体类数据Dao接口在config目录下进行Mapper文件配置Mybatis应用配置文件MyBatis-Configuration.xmlSpring配置文件,本例中我们放在/WebRoot/WEB-INF/...
精通Spring整合MyBatis：架构师的实践指南
最新发布
12-13
首先，Spring整合MyBatis的核心在于如何管理MyBatis的Mapper接口的动态代理。在整合时，Spring通过其IoC容器，自动地将MyBatis的Mapper接口实例化为Spring beans，这使得MyBatis的Mapper能够像普通的Spring beans...
Spring+myBatis 整合两种方法，一种是dao 整合，一种是mapper接口代理
03-05
需要数据库，可以自行建立，建立一个tb_user 表，表中主要有id ,username loginname,password,phone,address几个字段。
惊呆了，spring中竟然有12种定义bean的方法
码农小胖哥
07-13 1387
前言在庞大的java体系中，spring有着举足轻重的地位，它给每位开发者带来了极大的便利和惊喜。我们都知道spring是创建和管理bean的工厂，它提供了多种定义bean的方式，能够满足...
Spring中自定义Bean
AdrainHuang的博客
02-13 2606
前言：此文章是本人在阅读Spring Framework官方文档Customizing the Nature of a Bean章节做的部分理解，可能并不适合广大的群众。若有理解不到位或者有错误的地方请指出。 官方文档：https://docs.spring.io/spring/docs/5.1.4.RELEASE/spring-framework-reference/core.html#bea...
Spring扫描Mybatis的mapper接口的三种配置方式
热门推荐
源码之下，了无秘密
02-21 2万+
mybatis支持与spring结合使用，使得mybatis中的mapper接口可以作为spring容器中的bean被应用代码中相关类，如Service类，通过@Autowired自动注入进来。在使用方面需要在项目中引入以下包： &amp;amp;lt;dependency&amp;amp;gt; &amp;amp;lt;groupId&amp;amp;gt;org.mybatis&amp;amp;lt;/groupId&amp;amp;gt;
spring自定义Bean的创建
无名程序员
07-27 790
spring自定义Bean的创建 背景 众所周知,spring创建Bean的方式为工厂方式,如果想在Bean创建的时候做下扩展处理,spring停供了相应的扩展点进行扩展. spring在容器初始化时,先读取Bean的定义,例如xml中的定义,config class中的定义,存储在beanDefinitionMap 中 如果想改变Bean的内容,可以改变Bean的定义,从而使之后的Bean的创建实例都改变 BeanFactoryPostProcessor就是用来改变Bean的定义的,Abstr
Spring Framework学习之路（16）--- 自定义Bean范围
极乐净土
05-06 200
Bean 范围
Java全栈工程师-SSM框架整合
07-22
本课程完整地讲解SpringMVC+Spring+MyBatis三大框架的整合步骤 本课程以CRM小系统为案例讲解SSM环境的使用和分页插件
MyBatis之整合Spring（Dao和Mapper两种方式）
零度的博客专栏
09-18 7826
1. 基础环境搭建 　　首先环境肯定得有，环境嘛，除了Java环境和开发环境外，那就是jar包咯，关于mybatis和spring整合的jar包，我已经上传到下载频道了==>传送门  　　 将这些jar包导入到lib文件夹中即可，然后就是工程中的一些文件了，配置文件啊，java文件啊等，先看一下整个工程的结构。    　　下面来完成所有的整合步骤。  2. 配置文件 　　在
spring 整合mybatis
08-14
SqlSessionFactoryBean是MyBatis的核心类，用于创建SqlSession对象，而MapperScannerConfigurer用于自动扫描和注册Mapper接口。 6. 最后，在您的代码中使用@Autowired注解将Mapper接口注入到需要使用数据库操作的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值