MyBatis Mapper.xml文件中 和#的区别

Posted 2023-05-03

参考技术A 1.优先使用#paramName,jdbcType=VARCHAR写法，除了可以防止sql注入以外，它还能在参数里含有单引号的时候自动转义，而$paramName由于是类似于拼接sql的写法，不具备此功能。2.注意，使用#paramName,jdbcType=VARCHAR写法的时候，模糊 参考技术B 没办法通用的，一个表对应一个mapper.xml文件，
现在都是用过插件mybatis-generator-core自动生成的，不用修改即可满足使用基本的增删改查，
如需扩展，只需在自动生成的文件内容基础上额外定义自己的增删改查。本回答被提问者采纳

热加载 MyBatis 中修改过的 Mapper.xml

拿来即用的热加载 MyBatis 中修改过的 Mapper.xml

项目中使用的是 MyBatis, 在开发过程中, 每次修改完 SQL 都需要重新启动一遍项目, 非常耗时, 影响开发效率. 所以非常有必要热加载 修改过的 Mapper.xml 文件.

原理并不难 :

• 遍历所有的 xml 文件, 根据文件属性, 找到刚更新的文件
• 删除缓存中修改过的 xml 文件的解析对象
• 重新解析 xml 文件并保存

使用方式: 直接复制下面的类到 项目中, 启动项目即可看到如下输出, 说明启动成功

========= Enabled refresh mybatis mapper =========

修改完 SQL 以后, 更新一下资源

过几秒钟, 控制台即可看到更新的文件.

直接复制下面代码到 Spring 项目中, 即可生效 如果没有使用 Lombok, 直接删掉日志输出或者使用 System.out.println() 输出

package com.util.mybatis;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.SmartInitializingSingleton;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Mybatis的mapper文件中的sql语句被修改后, 只能重启服务器才能被加载, 非常耗时,所以就写了一个自动加载的类,
 * 配置后检查xml文件更改,如果发生变化,重新加载xml里面的内容.
 */
@Slf4j
@Component
public class MapperAutoRefresh implements ApplicationContextAware, SmartInitializingSingleton 
    /*容器上下文, 通过 Aware 填充*/
    private ApplicationContext applicationContext;
    /*是否启用 Mapper 刷新线程功能*/
    private static boolean enabled = true;
    /* Mapper.xml 实际资源路径集合 默认去 MyBatis 中已有的配置*/
    private Set<String> locationSet = new HashSet<>();
    /* MyBatis 中 xml 文件的路径列表, 用 File[] 包裹, 没法直接使用*/
    private Set<String> loadedResourcesSet;
    /*MyBatis配置对象*/
    private Configuration configuration;
    /*上一次刷新时间*/
    private Long beforeTime = 0L;
    /*延迟刷新秒数*/
    private static int delaySeconds = 10;
    /*休眠时间*/
    private static int sleepSeconds = 30;

    /**
     * 根据配置的 SqlSessionFactoryBean 的 mapperLocations 属性, 获取所有的 mapper.xml 的资源路径
     *
     * @see SqlSessionFactoryBean
     */
    @SuppressWarnings("unchecked")
    public void setLocation() 
        try 
            Field loadedResourcesField = Configuration.class.getDeclaredField("loadedResources");
            loadedResourcesField.setAccessible(true);
            this.loadedResourcesSet = ((HashSet<String>) loadedResourcesField.get(configuration));
            for (String locationPath : loadedResourcesSet) 
                if (locationPath.startsWith("file [")) 
                    String s = locationPath.substring("file [".length(), locationPath.lastIndexOf("]"));
                    locationSet.add(s);
                    log.info("Location:" + s);
                
            
         catch (NoSuchFieldException | IllegalAccessException e) 
            throw new RuntimeException(e);
        
    

    /**
     * 执行资源刷新任务
     */
    public void exeTask() 
        if (CollectionUtils.isEmpty(locationSet)) 
            return;
        
        beforeTime = System.currentTimeMillis();
        if (enabled) 
            new Thread(runnable).start();
        
    

    private Runnable runnable = () -> 
        try 
            // 暂定时间
            TimeUnit.SECONDS.sleep(delaySeconds);
            log.info("========= Enabled refresh mybatis mapper =========");
            // 开始执行刷新操作
            while (true) 
                for (String path : locationSet) 
                    this.refresh(path, beforeTime);
                
                TimeUnit.SECONDS.sleep(sleepSeconds);
            
         catch (InterruptedException e) 
            throw new RuntimeException(e);
        
    ;

    /**
     * 刷新资源的操作
     *
     * @param filePath   xml 文件路径
     * @param beforeTime 上次刷新事件
     */
    public void refresh(String filePath, long beforeTime) 
        // 本次刷新时间
        long refreshTime = System.currentTimeMillis();
        File file = new File(filePath);
        if (!checkFile(file, beforeTime)) 
            return;
        
        try 
            InputStream inputStream = new FileInputStream(file);
            // 清理原有资源，更新为自己的StrictMap方便增量重新加载
            String[] mapFieldNames = new String[]
                    "mappedStatements", "caches",
                    "resultMaps", "parameterMaps",
                    "keyGenerators", "sqlFragments"
            ;
            for (String fieldName : mapFieldNames) 
                Field field = Configuration.class.getDeclaredField(fieldName);
                field.setAccessible(true);
                Map map = ((Map) field.get(configuration));
                if (!(map instanceof StrictMap)) 
                    Map newMap = new StrictMap(StringUtils.capitalize(fieldName) + "collection");
                    for (Object key : map.keySet()) 
                        try 
                            newMap.put(key, map.get(key));
                         catch (IllegalArgumentException ex) 
                            newMap.put(key, ex.getMessage());
                        
                    
                    field.set(configuration, newMap);
                
            
            // 清理已加载的资源标识，方便让它重新加载。
            this.loadedResourcesSet.remove(filePath);
            //重新编译加载资源文件。
            XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(inputStream, configuration,
                    filePath, configuration.getSqlFragments());
            xmlMapperBuilder.parse();
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (NoSuchFieldException | IllegalAccessException e) 
            throw new RuntimeException(e);
         finally 
            ErrorContext.instance().reset();
        
        if (log.isDebugEnabled()) 
            log.info("Refresh file: " + file.getAbsolutePath());
            log.info("Refresh filename: " + file.getName());
        
        this.beforeTime = refreshTime;
    

    /**
     * 判断文件是否需要刷新,需要刷新返回true，否则返回false
     *
     * @param file       xml 文件
     * @param beforeTime 上次更新事件
     * @return 是否需要重新加载
     */
    private boolean checkFile(File file, Long beforeTime) 
        return file.lastModified() > beforeTime;
    


    /**
     * 重写 org.apache.ibatis.session.Configuration.StrictMap 类
     * 来自 MyBatis3.4.0版本，修改 put 方法，允许反复 put更新。
     *
     * @see org.apache.ibatis.session.Configuration.StrictMap
     */
    public static class StrictMap<V> extends HashMap<String, V> 

        private static final long serialVersionUID = -4950446264854982944L;
        private final String name;

        public StrictMap(String name, int initialCapacity, float loadFactor) 
            super(initialCapacity, loadFactor);
            this.name = name;
        

        public StrictMap(String name, int initialCapacity) 
            super(initialCapacity);
            this.name = name;
        

        public StrictMap(String name) 
            super();
            this.name = name;
        

        public StrictMap(String name, Map<String, ? extends V> m) 
            super(m);
            this.name = name;
        

        @SuppressWarnings("unchecked")
        @Override
        public V put(String key, V value) 
            // 核心逻辑, 先删除后添加
            if (enabled) 
                remove(key);
            
            if (containsKey(key)) 
                throw new IllegalArgumentException(name + " already contains value for " + key);
            
            if (key.contains(".")) 
                final String shortKey = getShortName(key);
                if (super.get(shortKey) == null) 
                    super.put(shortKey, value);
                 else 
                    super.put(shortKey, (V) new Ambiguity(shortKey));
                
            
            return super.put(key, value);
        

        @Override
        public V get(Object key) 
            V value = super.get(key);
            if (value == null) 
                throw new IllegalArgumentException(name + " does not contain value for " + key);
            
            if (value instanceof Ambiguity) 
                throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
                        + " (try using the full name including the namespace, or rename one of the entries)");
            
            return value;
        

        private String getShortName(String key) 
            final String[] keyParts = key.split("\\\\.");
            return keyParts[keyParts.length - 1];
        

        protected static class Ambiguity 
            private String subject;

            public Ambiguity(String subject) 
                this.subject = subject;
            

            public String getSubject() 
                return subject;
            
        

    

    /**
     * 单例实例化完成后执行
     */
    @Override
    public void afterSingletonsInstantiated() 
        SqlSessionFactory sessionFactory = applicationContext.getBean(SqlSessionFactory.class);
        this.configuration = sessionFactory.getConfiguration();
        setLocation();
        exeTask();
    

    /**
     * 赋值 applicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
        this.applicationContext = applicationContext;