mybatis插件

最新推荐文章于 2024-06-02 12:37:06 发布
最新推荐文章于 2024-06-02 12:37:06 发布
阅读量173 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ax___xa/article/details/115044761
版权

InsertOrUpdatePluging

@Intercepts({
      @Signature(type = Executor.class,method = "update",args = {MappedStatement.class,Object.class})
})
public class InsertOrUpdatePluging implements Interceptor {
    private final  ReflectorFactory reflectorFactory =  new DefaultReflectorFactory();
    private Set<Field> fieldInsertSet;
    private Set<Field> fieldUpdateSet;
    private SqlCommandType sqlCommandType;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        fieldInsertSet = new HashSet<>(0);
        fieldUpdateSet = new HashSet<>(0);
        MetaObject metaObject = SystemMetaObject.forObject(invocation.getArgs()[0]);
        sqlCommandType = (SqlCommandType)metaObject.getValue("sqlCommandType");
        Object params = invocation.getArgs()[1];
        getAnnotationParams(params);
        if(isJavaBean(params)) {
            if (sqlCommandType.equals(SqlCommandType.UPDATE)) {
                if(fieldUpdateSet.size()>0){
                    fieldUpdateSet.forEach(f -> {
                        resolverObject(params, f);
                    });
                }else if(isMapBean(params)){
                    ((Map)params).put("modifyTime",new Date().getTime());
                    String userName = StringUtils.isEmpty(UserDetailsUtils.getSysRealName())?UserDetailsUtils.getSysUsername()
                            :UserDetailsUtils.getSysRealName();
                    ((Map)params).put("modifyUser",userName);
                }
            } else if(sqlCommandType.equals(SqlCommandType.INSERT) && fieldInsertSet.size()>0){
                fieldInsertSet.forEach(f -> {
                    resolverObject(params, f);
                });
            }
        }
        invocation.getArgs()[1] = params;
        return invocation.proceed();
    }

    private boolean isMapBean(Object params) {
        return Map.class.isAssignableFrom(params.getClass());
    }

    private void resolverObject(Object o,Field f){
        MetaObject argObject = SystemMetaObject.forObject(o);
        Object value = null;
        if(f.getDeclaredAnnotation(CreateTime.class) != null || f.getDeclaredAnnotation(ModifyTime.class) != null){
            if(f.getDeclaredAnnotation(CreateTime.class) != null){
                CreateTime createTime = f.getDeclaredAnnotation(CreateTime.class);
                value = resovelTime(createTime.type(),createTime.partten());
            }else{
                ModifyTime modifyTime = f.getDeclaredAnnotation(ModifyTime.class);
                value = resovelTime(modifyTime.type(),modifyTime.partten());
            }
        }else{
            value = StringUtils.isEmpty(UserDetailsUtils.getSysRealName())?UserDetailsUtils.getSysUsername()
                    :UserDetailsUtils.getSysRealName();
        }
        argObject.setValue(f.getName(),value);
    }

    private Object resovelTime(Timesolt clazz,String partten){
        Object value;
        switch (clazz){
            case DATE:value = new Date();break;
            case STRING: {
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat(partten);
                value = simpleDateFormat.format(new Date());
                break;
            }
            case LONG:
            default:value = new Date().getTime();

        }
        return value;
    }

    private boolean isJavaBean(Object o){
        Reflector reflector = reflectorFactory.findForClass(o.getClass());
        return reflector.getGetablePropertyNames().length > 0 || reflector.getSetablePropertyNames().length > 0;
    }

    private void getAnnotationParams(Object o) {
        Field[] declaredFields = o.getClass().getDeclaredFields();
        for (Field declaredField : declaredFields) {
            if(declaredField.getAnnotation(CreateTime.class) != null
                    || declaredField.getAnnotation(CreateUser.class) != null){
                fieldInsertSet.add(declaredField);
            }
            if(declaredField.getAnnotation(ModifyTime.class) != null
                    || declaredField.getAnnotation(ModifyUser.class) != null){
                fieldInsertSet.add(declaredField);
                fieldUpdateSet.add(declaredField);
            }
        }
    }

    @Override
    public Object plugin(Object o) {
        return Plugin.wrap(o,this);
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

这个插件的作用是在插入数据或者更新数据时候只需要在实体类加上@CreateTime 、@ModifyTime 、@CreateUser、@ModifyUser注解即可在数据插入或者更新到数据库时候自动填充创建时间，修改时间，创建人，修改人等数据，会根据给定注解选择填充值。UserDetailsUtils为封装的Spring security工具类，可以获取当前登录用户信息。这个插件拓展的是Executor执行器的update方法，因为mybatis插入更新其实都是调用的mybatis的Executor中的update方法，invocation.getArgs()方法得到的其实就是@Signature注解里面的args参数，也就是MappedStatement.class以及Object.class，MappedStatement其实就是对应着接口中的一个个方法的，其中包含了sqlCommandType，MetaObject 也是mybatis的一个工具类，其中通过反射将对象的信息全部保存为自己的属性，并对外外提供一系列方法，比如设置值，取值等等。我们可以通过MetaObject 拿到MappedStatement里的sqlCommandType类型来判断当前操作是新增还是更新。第二个Object类型的参数就是我们更新或者新增是传递的对象，只需要根据注解以及sqlCommandType类型以及上面所述的四个注解像第二个参数对象填充即可。

至于如何将自定义插件注册，SqlSessionFactoryBean中有Mybatis中的Configuration对象，我们可以通过SqlSessionFactoryBean像mybatis注册插件，下面是我在项目中注册插件代码。

MybatisHrMysqlConfig

@Configuration
@MapperScan(basePackages = {"com.gkss.hr.web.dao.hr.**"},
        sqlSessionTemplateRef = "hrSqlSessionTemplateMysql")
public class MybatisHrMysqlConfig implements ResourceLoaderAware {


    private final static String DAO_CLASS_PATH = "classpath*:com/gkss/hr/web/dao/hr/*.class";

    @Autowired
    @Qualifier("hrDataSource")
    private DataSource mysql;

    private ResourceLoader resourceLoader;

    @Bean(name = "hrMysqlTransactionManager") // 配置事务
    public DataSourceTransactionManager testTransactionManager() {
        return new DataSourceTransactionManager(mysql);
    }

    @Bean(name = "hrSqlSessionTemplateMysql")
    public SqlSessionTemplate sqlSessionTemplateMysql() throws Exception {
        SqlSessionTemplate template = new SqlSessionTemplate(this.sqlSessionFactoryMysql());
        return template;
    }

    @Primary
    @Bean("hrSqlSessionFactoryMysql")
    public SqlSessionFactory sqlSessionFactoryMysql() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setTypeHandlers(new TypeHandler[]{new StringTypeHandler(),new IntegerTypeHandler(),new JSONArrayHandler()});
        //插件
        factoryBean.setPlugins(new Interceptor[]{new InsertOrUpdatePluging()});
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        //数据源
        factoryBean.setDataSource(mysql);
        // 设置mybatis的xml所在位置
        factoryBean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath*:/mapper/hr/*.xml"));
        //开启驼峰
        configuration.setMapUnderscoreToCamelCase(true);
        putAllcolumnAndConditionForConfiguretion(configuration,true);
        factoryBean.setConfiguration(configuration);
        return factoryBean.getObject();
    }

    private void putAllcolumnAndConditionForConfiguretion(org.apache.ibatis.session.Configuration configuration,boolean resolve) throws Exception {
        List<Class<?>> classByPath = getClassByPath(DAO_CLASS_PATH);
        classByPath.forEach(v->{
            SqlEntity declaredAnnotation = v.getDeclaredAnnotation(SqlEntity.class);
            if(declaredAnnotation != null){
                StringBuffer allcolumnStr = new StringBuffer("");
                StringBuffer conditionStr = new StringBuffer("");
                Class<?> clazz = declaredAnnotation.clazz();
                String prifex = declaredAnnotation.prifex().isEmpty()?"":declaredAnnotation.prifex()+".";
                for(Field field : clazz.getDeclaredFields()){
                    field.setAccessible(true);
                    if(field.getDeclaredAnnotation(Transient.class) == null){
                        allcolumnStr.append(prifex+(resolve?underscoreName(field.getName(),resolve):field.getName())+",");
                        String fieldN = resolve ? underscoreName(field.getName(),resolve) : field.getName();
                        if(field.getType().isAssignableFrom(String.class)){
                            conditionStr.append(" <if test=\""+field.getName()+" != null and "+field.getName()+" != ''\">");
                        }else{
                            conditionStr.append(" <if test=\""+field.getName()+" != null\">");
                        }
                        conditionStr.append("and "+prifex+fieldN+"=#{"+field.getName()+"}");
                        conditionStr.append(" </if>");
                    }
                }

                final String MAPPER_AllCOLUMN = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
                        + "<sql>\n"
                        + "  "+allcolumnStr.substring(0,allcolumnStr.length()-1)+"\n"
                        + "</sql>\n";

                final String MAPPER_CONDITION = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n"
                        + "<sql>\n"
                        + "  "+conditionStr.toString()+"\n"
                        + "</sql>\n";
                configuration.getSqlFragments().put(v.getName()+".condition",new XPathParser(MAPPER_CONDITION).evalNode("sql"));
                configuration.getSqlFragments().put(v.getName()+".allcolumn",new XPathParser(MAPPER_AllCOLUMN).evalNode("sql"));
            }
        });
    }


    private List<Class<?>> getClassByPath(String path) throws Exception{
        List<Class<?>> classList = new ArrayList<Class<?>>();
        ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
        MetadataReaderFactory metaReader = new CachingMetadataReaderFactory(resourceLoader);
        Resource[] resources = resolver.getResources(path);

        for (Resource r : resources) {
            MetadataReader reader = metaReader.getMetadataReader(r);
            Class<?> clazz = Class.forName(reader.getClassMetadata().getClassName());
            classList.add(clazz);
        }
        return classList;
    }

    /**
     * 将驼峰式命名的字符串转换为下划线大写方式。如果转换前的驼峰式命名的字符串为空，则返回空字符串。</br>
     * 例如：HelloWorld->hello_word
     * @param param 转换前的驼峰式命名的字符串
     * @return 转换后下划线大写方式命名的字符串
     */
    public static String underscoreName(String param,boolean lowcase) {
        if (param == null || "".equals(param.trim())) {
            return "";
        }
        int len = param.length();
        StringBuilder sb = new StringBuilder(len);
        for (int i = 0; i < len; i++) {
            char c = param.charAt(i);
            if (Character.isUpperCase(c)) {
                sb.append("_");
            }
            if (lowcase) {
                sb.append(Character.toLowerCase(c));  //统一都转大写
            } else {
                sb.append(Character.toUpperCase(c));  //统一都转小写
            }


        }
        return sb.toString();
    }

    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        this.resourceLoader = resourceLoader;
    }


    public static void main(String[] args) {
        System.out.println(underscoreName("userId",true));
    }

}

其中有个putAllcolumnAndConditionForConfiguretion方法用来扫描指定包下面的所有Dao接口，拿到其中包含@SqlEntity注解Dao通过反射将属性拼接成Sql然后注册到Configuretion的sqlFragments属性中，这个属性是个Map类型对象，里面保存了<sql>标签定义的sql语句片段，之前XML中每次都要写如下图这种<sql>片段
在这里插入图片描述
上面的putAllcolumnAndConditionForConfiguretion方法会在项目启动时自动将这些SQL片段注册到Configuretion中，以后编写XML时省去了写上图SQL片段的步骤，简便开发提高开发速度。使用如下图
在这里插入图片描述

在这里插入图片描述
在Dao接口上面标注@SqlEntity注解，直接在XML使用include标签即可。

注解


@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface SqlEntity {
    Class<?> clazz();
    String prifex() default "";
}


@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CreateTime {
    Timesolt type() default Timesolt.LONG;
    String partten() default "yyyy-MM-dd hh:mm:ss";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CreateUser {
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyTime {
    Timesolt type() default Timesolt.LONG;
    String partten() default "yyyy-MM-dd hh:mm:ss";
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ModifyUser {
}

UserDetailsUtils

public class UserDetailsUtils {

    /**
     * 获取当前登录用户权限.
     */
    public static List<HrPermission> getSysUserPermissionList(Integer permissionType) {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return new ArrayList<>(0);
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getPermissionMap().get(permissionType);
    }

    /**
     * 获取当前登录用户权限.
     */
    public static List<HrDepartment> getSysUserDepartmentList() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return new ArrayList<>(0);
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getHasDepartmentList();
    }

    /**
     * 获取当前登录用户权限.
     */
    public static List<HrDepartment> getSysUserDepartmentTreeList() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return new ArrayList<>(0);
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getHasDepartmentTreeList();
    }


    /**
     * 获取当前登录用户账号.
     */
    public static String getSysUsername() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return "";
        }
        return ((UserDetails) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getUsername();
    }


    public static String getSysRealName() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return "";
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getHrUser().getRealname();
    }


    /**
     * 获取当前登录用户实体.
     */
    public static HrUser getSysUser() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return null;
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getHrUser();
    }


    /**
     * 获取当前登录用户实体.
     */
    public static Integer getSysUserId() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return null;
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal()).getHrUser().getUserId();
    }

    /**
     * 获取当前登录用户实体.
     */
    public static UsersDetail getSysUserDetail() {
        if ("anonymousUser".equals(SecurityContextHolder.getContext().getAuthentication().getPrincipal())) {
            return null;
        }
        return ((UsersDetail) SecurityContextHolder.getContext().getAuthentication().getPrincipal());
    }


    /**
     * 全局获取HttpServletResponse对象
     */
    public static HttpServletResponse getHttpServletResponse() {
        HttpServletResponse response = ((ServletWebRequest) RequestContextHolder.getRequestAttributes()).getResponse();
        return response;
    }

    /**
     * 全局获取HttpServletRequest对象
     */
    public static HttpServletRequest getHttpServletRequest() {
        HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
        return request;
    }


}

最近
在这里插入图片描述
上图是mybatis注册插件代码
在这里插入图片描述
在这里插入图片描述
上面是mybatis注册插件的代码片段，是通过责任链以及动态代理来实现插件拓展的。在参数准备，结果处理，语句准备和语句执行时均可以注册自己编写的插件来改变mybatis的行为。

ax___xa
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
2.Mybatis XML 方法的基本用法
半夏_2021的博客
09-12 715
Mybatis XML 方法的基本用法,包含 参数映射、输入映射和输出映射、resultMap、传递多个参数、#和 $区别、自定义主键返回、sql标签、动态sql、
MyBatis插件
05-03
在提到的"MyBatis插件"中，我们可能是在讨论MyBatis的拦截器插件。这些插件允许开发者对MyBatis的执行过程进行拦截和增强，例如日志记录、性能分析、动态SQL等。MyBatis提供了Interceptor接口，开发人员可以通过实现...
Mybatis插件处理createTime和updateTime
焱童鞋
01-21 1414
自定义注解CreatedTimeTag和UpdateTimeTag处理2个时间字段 @Retention(RetentionPolicy.RUNTIME) @Target( {ElementType.FIELD}) public @interface CreatedTimeTag { String value() default ""; } @Retention(RetentionPolicy.RUNTIME) @Target( {ElementType.FIELD}) public @in
Mybatis拦截器统一管理创建人、更新人、创建时间、更新时间等公共字段
m0_47743175的博客
11-26 2975
Mybatis拦截器统一管理创建人、更新人、创建时间、更新时间等公共字段
MyBatis源码解析系列之十二：自定义插件开发
最新发布
阿里渣渣java研发组-群主
06-02 409
欢迎回到我的MyBatis源码解析系列。在前几篇文章中，我们详细介绍了MyBatis的架构及其核心组件的实现原理，并深入探讨了MyBatis与Spring的集成。本篇文章将探讨如何开发自定义插件，以扩展MyBatis的功能，满足特定的业务需求。MyBatis插件机制基于Java的动态代理，允许开发者通过实现接口来拦截执行的核心方法，从而实现诸如性能监控、日志记录、SQL重写等功能。Executor：执行器，负责SQL语句的执行。：语句处理器，负责SQL语句的生成和参数设置。
springboot+mybatis多数据源分布式事务管理
qq_37703810的博客
03-02 243
springboot+mybatis+Atomikos+JTA+XA规范
Mybatis学习之插件
wsb_2526的博客
06-14 4780
创建自定义插件类实现Interceptor接口；使用@Intercepts注解：指定插件拦截四大对象中指定对象的指定方法；在全局配置文件中注册插件这里使用@Intercepts注解指定了拦截Executor对象的update方法和query方法，由于接口中存在重载方法，所以通过args指定方法的参数来确定是哪一个方法。/*** 拦截目标对象的目标方法的执行System . out . println("要拦截的方法: " + invocation . getMethod());
mybatis插件直接可用
07-04
而"Idea MyBatis插件"则是针对IntelliJ IDEA这个强大的Java集成开发环境设计的一款增强工具，它可以提供更高效、便捷的MyBatis开发体验。 该插件的直接可用性意味着用户无需复杂设置，只需按照指定路径将其放置在...
IDEA的MyBatis插件两个
03-07
本篇文章将详细介绍两个针对MyBatis框架的IntelliJ IDEA插件——MyBatisCodeHelper-Pro和MybatisX，它们都是为了提升MyBatis开发体验而设计的。 首先，我们来看MyBatisCodeHelper-Pro。这款插件是专为MyBatis开发者...
mybatis 插件
08-29
Idea是一款强大的Java集成开发环境，而MyBatis插件则可以集成到Idea中，帮助开发者提高开发效率，例如自动生成Mapper接口、XML配置文件，自动提示SQL语句等。 描述中提到的"Idea2018.1"指的是这个MyBatis插件适用于...
2.mybatis实用小插件
黄裳博客
03-18 4956
        我们在使用 MyBatis时，经常会用到一些单表查询，但是不得不在 *Mapper.xml 中写简单 sql，而如 selectUserBy(Long id) 这种情况，也需要在 Mapper.xml文件中写select * from user where id = #{id} ，我觉得这是不必要的，也是多余的，不外乎现在也有一些mybatis 插件来帮助我们避免 sql 的编写，如 baomidou 插件，但是
Mybatis插件
qq_40977467的博客
05-17 2555
Mybatis插件 插件简介 一般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者自行拓展。这样的好处是显而易见的，一是增加了框架的灵活性。二是开发者可以结合实际需求，对框架进行拓展，使其能够更好的工作。以MyBatis为例，我们可基于MyBatis插件机制实现分页、分表，监控等功能。由于插件和业务 无关，业务也无法感知插件的存在。因此可以无感植入插件，在无形中增强功能 Mybatis插件介绍 Mybatis作为一个应用广泛的优秀的ORM开源框架，这个框架具有强大的灵活性，在四大组件(Executo
Mybatis_第⼋部分：Mybatis插件
qq_52922453的博客
06-05 1332
这样的好处是显⽽易⻅的，⼀是增加了框架的灵活性。初始化的时候创建的。来说插件就是拦截器，⽤来增强核⼼对象的功能，增强功能本质上是借助于底层的 动态代理实现的，换句话说，MyBatis。顺序写到这，不要多也不要少，如果⽅法重载，可是要通过⽅法名和⼊参来确定唯⼀的。⽅法会 对所拦截的⽅法进⾏检测，以决定是否执⾏插件逻辑。插件初始化的时候调⽤，也只调⽤⼀次，插件配置的属性从这⾥设置进来。是将分⻚的复杂操作进⾏封装，使⽤简单的⽅式即可获得分⻚的相关数据。注解中，若是，则执⾏插件逻辑，否则执⾏被拦截⽅法。
mybatis入门
weixin_44222931的博客
12-12 495
1、搭建mybatis框架环境 搭建maven项目如图 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" ...
最好用的Mybatis插件：IDEA中MyBatisCodeHelperPro插件下载安装（全版本）、MyBatisCodeHelperPro插件激活方法、支持Windows/Mac系统（保姆级教程）
热门推荐
zhangfuping123456789的博客
01-16 1万+
mybatis、MybatisCodeHelperPro、IDEA插件
Mybatis模块（十三）
行者彡的博客
10-27 189
Java综合常见面试题+ 答案汇总https://blog.csdn.net/sinat_21843047/article/details/109247405 Mybatis 125.mybatis 中 #{}和 ${}的区别是什么？ #{}是预编译处理，KaTeX parse error: Expected 'EOF', got '#' at position 21: …串替换； Mybatis在处理#̲{}时，会将sql中的#{}替…{}时，就是把${}替换成变量的值； 使用#{}可以有效的防..

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值