`
thinkgem
  • 浏览: 587221 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

实现MyBatis Mapper XML文件增量动态刷新,自动加载,热加载,热部署

阅读更多

    最初启动服务后Mapper XML文件,必须重启服务才能生效,这样就大大影响了我们的开发效率。

    网上同学们也有实现类似功能,但都是全部清空,全部刷新XML,这样硬件消耗比较严重,加载时间也比较长。我们只修改了几行SQL就没有必要全部加载,只需要加载修改的问题就行了。

    后来为了急需解决这个问题,进行修改MyBatis源码实现Mapper XML增量刷新,直接覆盖方式实现,使用classloader的加载机制优先加载,并应用到了jeesite中,但是经过MyBatis几次升级后,不得不需要重新修改,部署也麻烦,入侵性太强。

    周末有幸又重新研究下源代码将刷新部分,分离出来,实现MyBatis Mapper文件动态重新加载,只加载修改的文件,今天分享出来,不多说,看源码,注释很详细: 

/**
 * Copyright (c) 2012-Now https://github.com/thinkgem/jeesite.
 */
package com.thinkgem.jeesite.mybatis.thread;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

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.log4j.Logger;
import org.springframework.core.NestedIOException;
import org.springframework.core.io.Resource;

import com.google.common.collect.Sets;

/**
 * 刷新MyBatis Mapper XML 线程
 * @author ThinkGem
 * @version 2016-5-29
 */
public class MapperRefresh implements java.lang.Runnable {

	public static Logger log = Logger.getLogger(MapperRefresh.class);

	private static String filename = "/mybatis-refresh.properties";
	private static Properties prop = new Properties();

	private static boolean enabled;			// 是否启用Mapper刷新线程功能
	private static boolean refresh; 		// 刷新启用后,是否启动了刷新线程
	
	private Set<String> location;			// Mapper实际资源路径
	
	private Resource[] mapperLocations;		// Mapper资源路径
	private Configuration configuration;		// MyBatis配置对象
	
	private Long beforeTime = 0L; 			// 上一次刷新时间
	private static int delaySeconds;		// 延迟刷新秒数
	private static int sleepSeconds;		// 休眠时间
	private static String mappingPath;		// xml文件夹匹配字符串,需要根据需要修改

	static {
		
		try {
			prop.load(MapperRefresh.class.getResourceAsStream(filename));
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("Load mybatis-refresh “"+filename+"” file error.");
		}

		enabled = "true".equalsIgnoreCase(getPropString("enabled"));
		
		delaySeconds = getPropInt("delaySeconds");
		sleepSeconds = getPropInt("sleepSeconds");
		mappingPath = getPropString("mappingPath");

		delaySeconds = delaySeconds == 0 ? 50 : delaySeconds;
		sleepSeconds = sleepSeconds == 0 ? 3 : sleepSeconds;
		mappingPath = StringUtils.isBlank(mappingPath) ? "mappings" : mappingPath;

		log.debug("[enabled] " + enabled);
		log.debug("[delaySeconds] " + delaySeconds);
		log.debug("[sleepSeconds] " + sleepSeconds);
		log.debug("[mappingPath] " + mappingPath);
	}

	public static boolean isRefresh() {
		return refresh;
	}

	public MapperRefresh(Resource[] mapperLocations, Configuration configuration) {
		this.mapperLocations = mapperLocations;
		this.configuration = configuration;
	}

	@Override
	public void run() {

		beforeTime = System.currentTimeMillis();

		log.debug("[location] " + location);
		log.debug("[configuration] " + configuration);

		if (enabled) {
			// 启动刷新线程
			final MapperRefresh runnable = this;
			new Thread(new java.lang.Runnable() {
				@Override
				public void run() {
					
					if (location == null){
						location = Sets.newHashSet();
						log.debug("MapperLocation's length:" + mapperLocations.length);
						for (Resource mapperLocation : mapperLocations) {
							String s = mapperLocation.toString().replaceAll("\\\\", "/");
							s = s.substring("file [".length(), s.lastIndexOf(mappingPath) + mappingPath.length());
							if (!location.contains(s)) {
								location.add(s);
								log.debug("Location:" + s);
							}
						}
						log.debug("Locarion's size:" + location.size());
					}

					try {
						Thread.sleep(delaySeconds * 1000);
					} catch (InterruptedException e2) {
						e2.printStackTrace();
					}
					refresh = true;

					System.out.println("========= Enabled refresh mybatis mapper =========");

					while (true) {
						try {
							for (String s : location) {
								runnable.refresh(s, beforeTime);
							}
						} catch (Exception e1) {
							e1.printStackTrace();
						}
						try {
							Thread.sleep(sleepSeconds * 1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}

					}
				}
			}, "MyBatis-Mapper-Refresh").start();
		}
	}

	/**
	 * 执行刷新
	 * @param filePath 刷新目录
	 * @param beforeTime 上次刷新时间
	 * @throws NestedIOException 解析异常
	 * @throws FileNotFoundException 文件未找到
	 * @author ThinkGem
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	private void refresh(String filePath, Long beforeTime) throws Exception {

		// 本次刷新时间
		Long refrehTime = System.currentTimeMillis();

		// 获取需要刷新的Mapper文件列表
		List<File> fileList = this.getRefreshFile(new File(filePath), beforeTime);
		if (fileList.size() > 0) {
			log.debug("Refresh file: " + fileList.size());
		}
		for (int i = 0; i < fileList.size(); i++) {
			InputStream inputStream = new FileInputStream(fileList.get(i));
			String resource = fileList.get(i).getAbsolutePath();
			try {
				
				// 清理原有资源,更新为自己的StrictMap方便,增量重新加载
				String[] mapFieldNames = new String[]{
					"mappedStatements", "caches",
					"resultMaps", "parameterMaps",
					"keyGenerators", "sqlFragments"
				};
				for (String fieldName : mapFieldNames){
					Field field = configuration.getClass().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);
					}
				}
				
				// 清理已加载的资源标识,方便让它重新加载。
				Field loadedResourcesField = configuration.getClass().getDeclaredField("loadedResources");
				loadedResourcesField.setAccessible(true);
				Set loadedResourcesSet = ((Set)loadedResourcesField.get(configuration));
				loadedResourcesSet.remove(resource);
				
				//重新编译加载资源文件。
				XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(inputStream, configuration, 
						resource, configuration.getSqlFragments());
				xmlMapperBuilder.parse();
			} catch (Exception e) {
				throw new NestedIOException("Failed to parse mapping resource: '" + resource + "'", e);
			} finally {
				ErrorContext.instance().reset();
			}
			System.out.println("Refresh file: " + mappingPath + StringUtils.substringAfterLast(fileList.get(i).getAbsolutePath(), mappingPath));
			if (log.isDebugEnabled()) {
				log.debug("Refresh file: " + fileList.get(i).getAbsolutePath());
				log.debug("Refresh filename: " + fileList.get(i).getName());
			}
		}
		// 如果刷新了文件,则修改刷新时间,否则不修改
		if (fileList.size() > 0) {
			this.beforeTime = refrehTime;
		}
	}
	
	/**
	 * 获取需要刷新的文件列表
	 * @param dir 目录
	 * @param beforeTime 上次刷新时间
	 * @return 刷新文件列表
	 */
	private List<File> getRefreshFile(File dir, Long beforeTime) {
		List<File> fileList = new ArrayList<File>();

		File[] files = dir.listFiles();
		if (files != null) {
			for (int i = 0; i < files.length; i++) {
				File file = files[i];
				if (file.isDirectory()) {
					fileList.addAll(this.getRefreshFile(file, beforeTime));
				} else if (file.isFile()) {
					if (this.checkFile(file, beforeTime)) {
						fileList.add(file);
					}
				} else {
					System.out.println("Error file." + file.getName());
				}
			}
		}
		return fileList;
	}

	/**
	 * 判断文件是否需要刷新
	 * @param file 文件
	 * @param beforeTime 上次刷新时间
	 * @return 需要刷新返回true,否则返回false
	 */
	private boolean checkFile(File file, Long beforeTime) {
		if (file.lastModified() > beforeTime) {
			return true;
		}
		return false;
	}

	/**
	 * 获取整数属性
	 * @param key
	 * @return
	 */
	private static int getPropInt(String key) {
		int i = 0;
		try {
			i = Integer.parseInt(getPropString(key));
		} catch (Exception e) {
		}
		return i;
	}

	/**
	 * 获取字符串属性
	 * @param key
	 * @return
	 */
	private static String getPropString(String key) {
		return prop == null ? null : prop.getProperty(key);
	}

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

		private static final long serialVersionUID = -4950446264854982944L;
		private 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")
		public V put(String key, V value) {
			// ThinkGem 如果现在状态为刷新,则刷新(先删除后添加)
			if (MapperRefresh.isRefresh()) {
				remove(key);
				MapperRefresh.log.debug("refresh key:" + key.substring(key.lastIndexOf(".") + 1));
			}
			// ThinkGem end
			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);
		}

		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;
			}
		}
	}
}

 

 MyBatis有几个不太好的地方,是当实体类别名重名的时候,Mapper XML有错误的时候,系统启动时会一直等待无法正常启动(其实是加载失败后又重新加载,进入了死循环),这里我也顺便重写下SqlSessionFactoryBean.java文件,解决这个问题,在这个文件里也加入启动上面写的线程类:

 

 1、修改实体类重名的时候抛出并打印异常,否则系统会一直递归造成无法启动。

 2、MapperXML有错误的时候抛出并打印异常,否则系统会一直递归造成无法启动。

 3、加入启动MapperRefresh.java线程服务。 

/**
 *    Copyright 2010-2015 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package com.thinkgem.jeesite.mybatis.spring;

import static org.springframework.util.Assert.notNull;
import static org.springframework.util.ObjectUtils.isEmpty;
import static org.springframework.util.StringUtils.hasLength;
import static org.springframework.util.StringUtils.tokenizeToStringArray;

import java.io.IOException;
import java.sql.SQLException;
import java.util.Properties;

import javax.sql.DataSource;

import org.apache.ibatis.builder.xml.XMLConfigBuilder;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.DatabaseIdProvider;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.type.TypeHandler;
import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.core.NestedIOException;
import org.springframework.core.io.Resource;
import org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy;

import com.thinkgem.jeesite.common.mybatis.thread.MapperRefresh;

/**
 * {@code FactoryBean} that creates an MyBatis {@code SqlSessionFactory}.
 * This is the usual way to set up a shared MyBatis {@code SqlSessionFactory} in a Spring application context;
 * the SqlSessionFactory can then be passed to MyBatis-based DAOs via dependency injection.
 *
 * Either {@code DataSourceTransactionManager} or {@code JtaTransactionManager} can be used for transaction
 * demarcation in combination with a {@code SqlSessionFactory}. JTA should be used for transactions
 * which span multiple databases or when container managed transactions (CMT) are being used.
 *
 * @author Putthibong Boonbong
 * @author Hunter Presnall
 * @author Eduardo Macarron
 * 
 * @see #setConfigLocation
 * @see #setDataSource
 * @version $Id$
 * @modify ThinkGem 2016-5-24 来自 MyBatisSpring1.2.3版本
 */
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {

  private static final Log LOGGER = LogFactory.getLog(SqlSessionFactoryBean.class);

  private Resource configLocation;

  private Resource[] mapperLocations;

  private DataSource dataSource;

  private TransactionFactory transactionFactory;

  private Properties configurationProperties;

  private SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

  private SqlSessionFactory sqlSessionFactory;

  //EnvironmentAware requires spring 3.1
  private String environment = SqlSessionFactoryBean.class.getSimpleName();

  private boolean failFast;

  private Interceptor[] plugins;

  private TypeHandler<?>[] typeHandlers;

  private String typeHandlersPackage;

  private Class<?>[] typeAliases;

  private String typeAliasesPackage;

  private Class<?> typeAliasesSuperType;

  //issue #19. No default provider.
  private DatabaseIdProvider databaseIdProvider;

  private ObjectFactory objectFactory;

  private ObjectWrapperFactory objectWrapperFactory;

  /**
   * Sets the ObjectFactory.
   * 
   * @since 1.1.2
   * @param objectFactory
   */
  public void setObjectFactory(ObjectFactory objectFactory) {
    this.objectFactory = objectFactory;
  }

  /**
   * Sets the ObjectWrapperFactory.
   * 
   * @since 1.1.2
   * @param objectWrapperFactory
   */
  public void setObjectWrapperFactory(ObjectWrapperFactory objectWrapperFactory) {
    this.objectWrapperFactory = objectWrapperFactory;
  }

  /**
   * Gets the DatabaseIdProvider
   *
   * @since 1.1.0
   * @return
   */
  public DatabaseIdProvider getDatabaseIdProvider() {
    return databaseIdProvider;
  }

  /**
   * Sets the DatabaseIdProvider.
   * As of version 1.2.2 this variable is not initialized by default. 
   *
   * @since 1.1.0
   * @param databaseIdProvider
   */
  public void setDatabaseIdProvider(DatabaseIdProvider databaseIdProvider) {
    this.databaseIdProvider = databaseIdProvider;
  }

  /**
   * Mybatis plugin list.
   *
   * @since 1.0.1
   *
   * @param plugins list of plugins
   *
   */
  public void setPlugins(Interceptor[] plugins) {
    this.plugins = plugins;
  }

  /**
   * Packages to search for type aliases.
   *
   * @since 1.0.1
   *
   * @param typeAliasesPackage package to scan for domain objects
   *
   */
  public void setTypeAliasesPackage(String typeAliasesPackage) {
    this.typeAliasesPackage = typeAliasesPackage;
  }

  /**
   * Super class which domain objects have to extend to have a type alias created.
   * No effect if there is no package to scan configured.
   *
   * @since 1.1.2
   *
   * @param typeAliasesSuperType super class for domain objects
   *
   */
  public void setTypeAliasesSuperType(Class<?> typeAliasesSuperType) {
    this.typeAliasesSuperType = typeAliasesSuperType;
  }

  /**
   * Packages to search for type handlers.
   *
   * @since 1.0.1
   *
   * @param typeHandlersPackage package to scan for type handlers
   *
   */
  public void setTypeHandlersPackage(String typeHandlersPackage) {
    this.typeHandlersPackage = typeHandlersPackage;
  }

  /**
   * Set type handlers. They must be annotated with {@code MappedTypes} and optionally with {@code MappedJdbcTypes}
   *
   * @since 1.0.1
   *
   * @param typeHandlers Type handler list
   */
  public void setTypeHandlers(TypeHandler<?>[] typeHandlers) {
    this.typeHandlers = typeHandlers;
  }

  /**
   * List of type aliases to register. They can be annotated with {@code Alias}
   *
   * @since 1.0.1
   *
   * @param typeAliases Type aliases list
   */
  public void setTypeAliases(Class<?>[] typeAliases) {
    this.typeAliases = typeAliases;
  }

  /**
   * If true, a final check is done on Configuration to assure that all mapped
   * statements are fully loaded and there is no one still pending to resolve
   * includes. Defaults to false.
   *
   * @since 1.0.1
   *
   * @param failFast enable failFast
   */
  public void setFailFast(boolean failFast) {
    this.failFast = failFast;
  }

  /**
   * Set the location of the MyBatis {@code SqlSessionFactory} config file. A typical value is
   * "WEB-INF/mybatis-configuration.xml".
   */
  public void setConfigLocation(Resource configLocation) {
    this.configLocation = configLocation;
  }

  /**
   * Set locations of MyBatis mapper files that are going to be merged into the {@code SqlSessionFactory}
   * configuration at runtime.
   *
   * This is an alternative to specifying "&lt;sqlmapper&gt;" entries in an MyBatis config file.
   * This property being based on Spring's resource abstraction also allows for specifying
   * resource patterns here: e.g. "classpath*:sqlmap/*-mapper.xml".
   */
  public void setMapperLocations(Resource[] mapperLocations) {
    this.mapperLocations = mapperLocations;
  }

  /**
   * Set optional properties to be passed into the SqlSession configuration, as alternative to a
   * {@code &lt;properties&gt;} tag in the configuration xml file. This will be used to
   * resolve placeholders in the config file.
   */
  public void setConfigurationProperties(Properties sqlSessionFactoryProperties) {
    this.configurationProperties = sqlSessionFactoryProperties;
  }

  /**
   * Set the JDBC {@code DataSource} that this instance should manage transactions for. The {@code DataSource}
   * should match the one used by the {@code SqlSessionFactory}: for example, you could specify the same
   * JNDI DataSource for both.
   *
   * A transactional JDBC {@code Connection} for this {@code DataSource} will be provided to application code
   * accessing this {@code DataSource} directly via {@code DataSourceUtils} or {@code DataSourceTransactionManager}.
   *
   * The {@code DataSource} specified here should be the target {@code DataSource} to manage transactions for, not
   * a {@code TransactionAwareDataSourceProxy}. Only data access code may work with
   * {@code TransactionAwareDataSourceProxy}, while the transaction manager needs to work on the
   * underlying target {@code DataSource}. If there's nevertheless a {@code TransactionAwareDataSourceProxy}
   * passed in, it will be unwrapped to extract its target {@code DataSource}.
   *
   */
  public void setDataSource(DataSource dataSource) {
    if (dataSource instanceof TransactionAwareDataSourceProxy) {
      // If we got a TransactionAwareDataSourceProxy, we need to perform
      // transactions for its underlying target DataSource, else data
      // access code won't see properly exposed transactions (i.e.
      // transactions for the target DataSource).
      this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();
    } else {
      this.dataSource = dataSource;
    }
  }

  /**
   * Sets the {@code SqlSessionFactoryBuilder} to use when creating the {@code SqlSessionFactory}.
   *
   * This is mainly meant for testing so that mock SqlSessionFactory classes can be injected. By
   * default, {@code SqlSessionFactoryBuilder} creates {@code DefaultSqlSessionFactory} instances.
   *
   */
  public void setSqlSessionFactoryBuilder(SqlSessionFactoryBuilder sqlSessionFactoryBuilder) {
    this.sqlSessionFactoryBuilder = sqlSessionFactoryBuilder;
  }

  /**
   * Set the MyBatis TransactionFactory to use. Default is {@code SpringManagedTransactionFactory}
   *
   * The default {@code SpringManagedTransactionFactory} should be appropriate for all cases:
   * be it Spring transaction management, EJB CMT or plain JTA. If there is no active transaction,
   * SqlSession operations will execute SQL statements non-transactionally.
   *
   * <b>It is strongly recommended to use the default {@code TransactionFactory}.</b> If not used, any
   * attempt at getting an SqlSession through Spring's MyBatis framework will throw an exception if
   * a transaction is active.
   *
   * @see SpringManagedTransactionFactory
   * @param transactionFactory the MyBatis TransactionFactory
   */
  public void setTransactionFactory(TransactionFactory transactionFactory) {
    this.transactionFactory = transactionFactory;
  }

  /**
   * <b>NOTE:</b> This class <em>overrides</em> any {@code Environment} you have set in the MyBatis
   * config file. This is used only as a placeholder name. The default value is
   * {@code SqlSessionFactoryBean.class.getSimpleName()}.
   *
   * @param environment the environment name
   */
  public void setEnvironment(String environment) {
    this.environment = environment;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void afterPropertiesSet() throws Exception {
    notNull(dataSource, "Property 'dataSource' is required");
    notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");

    this.sqlSessionFactory = buildSqlSessionFactory();
  }

  /**
   * Build a {@code SqlSessionFactory} instance.
   *
   * The default implementation uses the standard MyBatis {@code XMLConfigBuilder} API to build a
   * {@code SqlSessionFactory} instance based on an Reader.
   *
   * @return SqlSessionFactory
   * @throws IOException if loading the config file failed
   */
  protected SqlSessionFactory buildSqlSessionFactory() throws IOException {

    Configuration configuration;

    XMLConfigBuilder xmlConfigBuilder = null;
    if (this.configLocation != null) {
      xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
      configuration = xmlConfigBuilder.getConfiguration();
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'configLocation' not specified, using default MyBatis Configuration");
      }
      configuration = new Configuration();
      configuration.setVariables(this.configurationProperties);
    }

    if (this.objectFactory != null) {
      configuration.setObjectFactory(this.objectFactory);
    }

    if (this.objectWrapperFactory != null) {
      configuration.setObjectWrapperFactory(this.objectWrapperFactory);
    }

    if (hasLength(this.typeAliasesPackage)) {
      String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeAliasPackageArray) {
		// ThinkGem 修改实体类重名的时候抛出并打印异常,否则系统会一直递归造成无法启动
		try {
			configuration.getTypeAliasRegistry().registerAliases(packageToScan,
					typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
		} catch (Exception ex) {
			LOGGER.error("Scanned package: '" + packageToScan + "' for aliases", ex);
			throw new NestedIOException("Scanned package: '" + packageToScan + "' for aliases", ex);
		} finally {
			ErrorContext.instance().reset();
		}
		// ThinkGem end
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for aliases");
        }
      }
    }

    if (!isEmpty(this.typeAliases)) {
      for (Class<?> typeAlias : this.typeAliases) {
        configuration.getTypeAliasRegistry().registerAlias(typeAlias);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type alias: '" + typeAlias + "'");
        }
      }
    }

    if (!isEmpty(this.plugins)) {
      for (Interceptor plugin : this.plugins) {
        configuration.addInterceptor(plugin);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered plugin: '" + plugin + "'");
        }
      }
    }

    if (hasLength(this.typeHandlersPackage)) {
      String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
          ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
      for (String packageToScan : typeHandlersPackageArray) {
        configuration.getTypeHandlerRegistry().register(packageToScan);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Scanned package: '" + packageToScan + "' for type handlers");
        }
      }
    }

    if (!isEmpty(this.typeHandlers)) {
      for (TypeHandler<?> typeHandler : this.typeHandlers) {
        configuration.getTypeHandlerRegistry().register(typeHandler);
        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Registered type handler: '" + typeHandler + "'");
        }
      }
    }

    if (xmlConfigBuilder != null) {
      try {
        xmlConfigBuilder.parse();

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed configuration file: '" + this.configLocation + "'");
        }
      } catch (Exception ex) {
        throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
      } finally {
        ErrorContext.instance().reset();
      }
    }

    if (this.transactionFactory == null) {
      this.transactionFactory = new SpringManagedTransactionFactory();
    }

    configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

    if (this.databaseIdProvider != null) {
      try {
        configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
      } catch (SQLException e) {
        throw new NestedIOException("Failed getting a databaseId", e);
      }
    }

    if (!isEmpty(this.mapperLocations)) {
      for (Resource mapperLocation : this.mapperLocations) {
        if (mapperLocation == null) {
          continue;
        }

        try {
          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
              configuration, mapperLocation.toString(), configuration.getSqlFragments());
          xmlMapperBuilder.parse();
        } catch (Exception e) {
			// ThinkGem MapperXML有错误的时候抛出并打印异常,否则系统会一直递归造成无法启动
        	LOGGER.error("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        	throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
        } finally {
          ErrorContext.instance().reset();
        }

        if (LOGGER.isDebugEnabled()) {
          LOGGER.debug("Parsed mapper file: '" + mapperLocation + "'");
        }
      }
      
      // ThinkGem 启动刷新MapperXML定时器(有助于开发者调试)。
      new MapperRefresh(this.mapperLocations, configuration).run();
   	  
    } else {
      if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("Property 'mapperLocations' was not specified or no matching resources found");
      }
    }

    return this.sqlSessionFactoryBuilder.build(configuration);
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public SqlSessionFactory getObject() throws Exception {
    if (this.sqlSessionFactory == null) {
      afterPropertiesSet();
    }

    return this.sqlSessionFactory;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public Class<? extends SqlSessionFactory> getObjectType() {
    return this.sqlSessionFactory == null ? SqlSessionFactory.class : this.sqlSessionFactory.getClass();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public boolean isSingleton() {
    return true;
  }

  /**
   * {@inheritDoc}
   */
  @Override
  public void onApplicationEvent(ApplicationEvent event) {
    if (failFast && event instanceof ContextRefreshedEvent) {
      // fail-fast -> check all statements are completed
      this.sqlSessionFactory.getConfiguration().getMappedStatementNames();
    }
  }

} 

重写SqlSessionFactoryBean就的修改下Spring的MyBatis配置部分: 

<!-- MyBatis SqlSessionFactoryBean -->
    <bean id="sqlSessionFactory" class="com.thinkgem.jeesite.common.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.thinkgem.jeesite"/>
        <property name="typeAliasesSuperType" value="com.thinkgem.jeesite.persistence.BaseEntity"/>
        <property name="mapperLocations" value="classpath*:/mappings/**/*.xml"/>
		<property name="configLocation" value="classpath:/mybatis-config.xml"></property>
    </bean>

 

 最后附加上属性配置文件:mybatis-refresh.properties

#是否开启刷新线程
enabled=true
#延迟启动刷新程序的秒数
delaySeconds=60
#刷新扫描间隔的时长秒数
sleepSeconds=3
#扫描Mapper文件的资源路径
mappingPath=mappings
 

 

分享到:
评论
9 楼 u010199866 2018-06-07  
2018-06-07   15:42:44   [com.cjis.util.MapperRefresh]-[DEBUG]   [enabled] true
2018-06-07   15:42:44   [com.cjis.util.MapperRefresh]-[DEBUG]   [delaySeconds] 60
2018-06-07   15:42:44   [com.cjis.util.MapperRefresh]-[DEBUG]   [sleepSeconds] 3
2018-06-07   15:42:44   [com.cjis.util.MapperRefresh]-[DEBUG]   [mappingPath] com/cjis/mapping
2018-06-07   15:42:51   [com.cjis.util.MapperRefresh]-[DEBUG]   [location] null
2018-06-07   15:42:52   [com.cjis.util.MapperRefresh]-[DEBUG]   [configuration] org.apache.ibatis.session.Configuration@9367551
Exception in thread "MyBatis-Mapper-Refresh" java.lang.NoClassDefFoundError: com/google/common/collect/Sets
at com.cjis.util.MapperRefresh$1.run(MapperRefresh.java:101)
at java.lang.Thread.run(Thread.java:748)
Caused by: java.lang.ClassNotFoundException: com.google.common.collect.Sets
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1720)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1571)
... 2 more


按照楼主的操作,报错呢  请问这是为啥
8 楼 juxiaojun114 2018-03-04  
jeesite 使用idea导入开发,启动tomcat后为啥看不到========= Enabled refresh mybatis mapper =========  这个提示信息  使用eclipse没有这个问题,是我的idea设置有问题吗?
7 楼 aaddsfdsfsdfs 2017-12-18  
真心给个赞,可以的,忒提高开发效率了,配合自己写的通用后台框架,所有业务逻辑直接用js写的话,一次部署,后面基本都是热部署了,满意
6 楼 lovewinner 2017-04-17  
5 楼 空城旧梦已秋凉 2016-11-29  
为何不了解一下nutz框架
4 楼 zhugeyangyang1994 2016-06-18  
围观 大神
3 楼 agen19866 2016-06-16  
MyBatis SqlSessionFactoryBean

文件第5行一定要这样写么?
2 楼 8465279130 2016-06-15  
  赞!!!
1 楼 greatpwx 2016-06-13  

相关推荐

    IntelliJ IDEA修改了mybatis mapper xml后不用重启tomcat,自动热发布 热更新 热部署.zip

    总的来说,通过合理配置IDEA的自动构建选项,以及Mybatis Plus的热加载设置,我们可以实现在修改Mapper XML文件后,无需重启Tomcat即可看到更新效果,大大提高开发效率。如果遇到XML文件未被自动检测到更新的情况,...

    Spring+mvc+mybatis Mapper xml自动加载

    "Spring+mvc+mybatis Mapper xml自动加载"这个主题聚焦于如何在开发过程中优化配置,使得改动Mapper XML文件后,无需重启Tomcat服务器,就可以立即生效,从而提高开发效率。 Spring MVC是Spring框架的一部分,它...

    mybatis热部署mapper增量更新.

    MyBatis热部署Mapper增量更新是一种提高开发效率的方法,它允许开发者在运行时动态地替换或更新mapper文件,而无需中断服务。这种方式可以显著减少开发过程中的等待时间,提升开发体验。 要实现MyBatis的Mapper热...

    mybatis xml文件自动生成

    "mybatis xml文件自动生成"是开发过程中的一个重要环节,它可以帮助开发者提高效率,减少手动编写XML映射文件和对应的POJO(Plain Old Java Object)类的工作量。 MyBatis的Mapper文件是其核心组成部分之一,它包含...

    mybatis mapper 和xml文件生成

    本篇文章将深入探讨MyBatis的Mapper和XML文件生成,以及如何使用`mybatis-generator-core-1.3.2`工具进行自动化生成。 首先,让我们理解Mapper接口。Mapper接口是MyBatis中的一个关键概念,它允许开发者定义数据库...

    springboot mybatis mapper.xml 配置

    在Spring Boot集成MyBatis的过程中,`mapper.xml`配置文件起着至关重要的作用。它用于定义SQL语句,实现数据库的CRUD操作。本示例将深入探讨如何配置`mapper.xml`,并提供新增、修改、删除、查询及分页查询的实践...

    mybatis修改了mapper xml不用重启tomcat,热发布热更新.zip_mybatis的xml模糊查询

    mybatis修改了mapper xml不用重启tomcat,热发布热更新.zip

    mybatis基本文件xml、mapper等自动生成工具

    mybatis基本文件xml、mapper等自动生成工具 可自己根据自己的项目路径自行配置文件夹路径,本DEMO是使用的mysql数据库,可自行更换其他数据源 本DEMO会自动生成dao、model、mapper、xml文件,自带基本方法,可自动...

    mybatis mapper自动生成

    4. **整合**:最后,将生成的文件导入到Maven项目中,并在项目中配置MyBatis的SqlSessionFactory,确保能正确加载Mapper XML文件。 关于`mysql-connector-java-5.1.38.jar`,这是一个MySQL的JDBC驱动包,它是连接...

    idea好用的插件:Free Mybatis自动对应mapper层的xml文件

    idea好用的插件:Free Mybatis自动对应mapper层的xml文件

    mybatis自动生成mapper文件

    MyBatis Generator(MBG)是一款强大的工具,用于自动生成MyBatis的Mapper接口、XML映射文件以及对应的实体类。这款工具极大地提高了开发效率,减少了手动编写这些基础代码的工作量,使得开发者能够更专注于业务逻辑...

    mybatis Mapper.xml中传参多选 字符串形式逗号分隔 AND中拼接OR.rar

    标题和描述所提及的问题是关于如何在Mapper.xml文件中处理字符串形式的参数,这些参数由逗号分隔,并在`AND`语句中拼接`OR`子句来实现动态查询。这种场景在处理用户多选过滤条件时非常常见,比如在一个搜索框中,...

    mybatis_xml关联插件

    Mybatis 是一个流行的Java持久层框架,它简化了数据库操作,允许开发者将SQL语句直接写在XML映射文件中,提供了动态SQL的功能。在Eclipse这样的集成开发环境中,为了提高开发效率,我们可以配置Mybatis的插件,使得...

    mybatis自动生成mapper.xml文件

    本文将深入探讨如何在SpringBoot项目中整合MyBatis,并实现自动生成Mapper.xml文件、DAO接口以及对应的Model类。 首先,我们需要确保项目已经集成了SpringBoot和MyBatis的基础配置。这通常涉及以下步骤: 1. 添加...

    自动生成mybatis的mapper文件和bean

    4. **代码生成器**:MyBatis提供了一个强大的代码生成器(MyBatis Generator,MBG),可以根据数据库表结构自动生成Mapper接口、Mapper XML文件以及实体类。这大大减少了手动编码的工作量,保证了代码的规范性和一致...

    Mybatis Mapper的使用

    Mybatis Mapper通过动态代理机制,使得我们可以直接在XML映射文件中定义SQL,然后在接口中声明对应的方法,系统会在运行时自动生成实现类,这样就消除了对实现类的直接依赖。 下面我们将详细探讨Mybatis Mapper的几...

    springboot+mybatis(mybatis dao与xml文件自动生成)

    在Spring Boot和MyBatis框架集成的开发过程中,自动化生成DAO层接口与对应的XML配置文件可以极大地提高开发效率。下面将详细介绍如何实现这一功能,并深入探讨相关知识点。 首先,Spring Boot是一个快速开发框架,...

    mybatis generator自动生成DAO、Bean、MapperXML等文件

    3. **Mapper接口和XML映射文件**:Mapper接口是DAO接口的具体实现,它通过MyBatis的动态SQL功能来执行SQL。XML映射文件则包含了具体的SQL语句,包括元素(用于设置参数)、元素(用于获取结果集)。MBG会根据表的...

    MyBatis Mapper映射文件

    MyBatis Mapper映射文件

    java后端+mybatis-plus自动生成+xmlmapper模板+新增修改

    用mybatis-plus的自动生成器,我们一般只用到entity和mapperXML,其他mapper接口和service类都要自己写。 可以下载之后,根据自己表生成mapperXML,然后用全局替换来修改一些细节。

Global site tag (gtag.js) - Google Analytics