1949

Committed 09 Jul 2026 10:07PM UTC coverage: 90.381% (+0.1%) from 90.242%

Build # 1949

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1269 from mybatis/renovate/byte-buddy.version

Update byte-buddy.version to v1.18.11-jdk5

Coverage Stats

323 of 386 branches covered (83.68%)

949 of 1050 relevant lines covered (90.38%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

88.0

/src/main/java/org/mybatis/spring/mapper/MapperFactoryBean.java

/*
 * Copyright 2010-2026 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
 *
 *    https://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 org.mybatis.spring.mapper;

import static org.springframework.util.Assert.notNull;

import org.apache.ibatis.executor.ErrorContext;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.beans.factory.FactoryBean;

/**
 * BeanFactory that enables injection of MyBatis mapper interfaces. It can be set up with a SqlSessionFactory or a
 * pre-configured SqlSessionTemplate.
 * <p>
 * Sample configuration:
 *
 * <pre class="code">
 * {@code
 *   <bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true" lazy-init="true">
 *     <property name="sqlSessionFactory" ref="sqlSessionFactory" />
 *   </bean>
 *
 *   <bean id="oneMapper" parent="baseMapper">
 *     <property name="mapperInterface" value="my.package.MyMapperInterface" />
 *   </bean>
 *
 *   <bean id="anotherMapper" parent="baseMapper">
 *     <property name="mapperInterface" value="my.package.MyAnotherMapperInterface" />
 *   </bean>
 * }
 * </pre>
 * <p>
 * Note that this factory can only inject <em>interfaces</em>, not concrete classes.
 *
 * @author Eduardo Macarron
 *
 * @param <T>
 *          the generic type
 *
 * @see SqlSessionTemplate
 */
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {

  private Class<T> mapperInterface;

  private boolean addToConfig = true;

  /**
   * Instantiates a new mapper factory bean.
   */
  public MapperFactoryBean() {
    // intentionally empty
  }

  /**
   * Instantiates a new mapper factory bean.
   *
   * @param mapperInterface
   *          the mapper interface
   */
  public MapperFactoryBean(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  @Override
  protected void checkDaoConfig() {
    super.checkDaoConfig();

    notNull(this.mapperInterface, "Property 'mapperInterface' is required");

    var configuration = getSqlSession().getConfiguration();
    if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
      try {
        configuration.addMapper(this.mapperInterface);
      } catch (Exception e) {
        logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
        throw new IllegalArgumentException(e);
      } finally {
        ErrorContext.instance().reset();
      }
    }
  }

  @Override
  public T getObject() throws Exception {
    return getSqlSession().getMapper(this.mapperInterface);
  }

  @Override
  public Class<T> getObjectType() {
    return this.mapperInterface;
  }

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

  // ------------- mutators --------------

  /**
   * Sets the mapper interface of the MyBatis mapper
   *
   * @param mapperInterface
   *          class of the interface
   */
  public void setMapperInterface(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }

  /**
   * Return the mapper interface of the MyBatis mapper
   *
   * @return class of the interface
   */
  public Class<T> getMapperInterface() {
    return mapperInterface;
  }

  /**
   * If addToConfig is false the mapper will not be added to MyBatis. This means it must have been included in
   * mybatis-config.xml.
   * <p>
   * If it is true, the mapper will be added to MyBatis in the case it is not already registered.
   * <p>
   * By default addToConfig is true.
   *
   * @param addToConfig
   *          a flag that whether add mapper to MyBatis or not
   */
  public void setAddToConfig(boolean addToConfig) {
    this.addToConfig = addToConfig;
  }

  /**
   * Return the flag for addition into MyBatis config.
   *
   * @return true if the mapper will be added to MyBatis in the case it is not already registered.
   */
  public boolean isAddToConfig() {
    return addToConfig;
  }
}

1	/*
2	* Copyright 2010-2026 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.mybatis.spring.mapper;
17
18	import static org.springframework.util.Assert.notNull;
19
20	import org.apache.ibatis.executor.ErrorContext;
21	import org.mybatis.spring.SqlSessionTemplate;
22	import org.mybatis.spring.support.SqlSessionDaoSupport;
23	import org.springframework.beans.factory.FactoryBean;
24
25	/**
26	* BeanFactory that enables injection of MyBatis mapper interfaces. It can be set up with a SqlSessionFactory or a
27	* pre-configured SqlSessionTemplate.
28	* <p>
29	* Sample configuration:
30	*
31	* <pre class="code">
32	* {@code
33	* <bean id="baseMapper" class="org.mybatis.spring.mapper.MapperFactoryBean" abstract="true" lazy-init="true">
34	* <property name="sqlSessionFactory" ref="sqlSessionFactory" />
35	* </bean>
36	*
37	* <bean id="oneMapper" parent="baseMapper">
38	* <property name="mapperInterface" value="my.package.MyMapperInterface" />
39	* </bean>
40	*
41	* <bean id="anotherMapper" parent="baseMapper">
42	* <property name="mapperInterface" value="my.package.MyAnotherMapperInterface" />
43	* </bean>
44	* }
45	* </pre>
46	* <p>
47	* Note that this factory can only inject <em>interfaces</em>, not concrete classes.
48	*
49	* @author Eduardo Macarron
50	*
51	* @param <T>
52	* the generic type
53	*
54	* @see SqlSessionTemplate
55	*/
56	public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T> {
57
58	private Class<T> mapperInterface;
59
60	private boolean addToConfig = true;	1✔
61
62	/**
63	* Instantiates a new mapper factory bean.
64	*/
65	public MapperFactoryBean() {	1✔
66	// intentionally empty
67	}	1✔
68
69	/**
70	* Instantiates a new mapper factory bean.
71	*
72	* @param mapperInterface
73	* the mapper interface
74	*/
75	public MapperFactoryBean(Class<T> mapperInterface) {	1✔
76	this.mapperInterface = mapperInterface;	1✔
77	}	1✔
78
79	@Override
80	protected void checkDaoConfig() {
81	super.checkDaoConfig();	1✔
82
83	notNull(this.mapperInterface, "Property 'mapperInterface' is required");	1✔
84
85	var configuration = getSqlSession().getConfiguration();	1✔
86	if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {	1✔
87	try {
88	configuration.addMapper(this.mapperInterface);	1✔
89	} catch (Exception e) {	×
90	logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);	×
91	throw new IllegalArgumentException(e);	×
92	} finally {
93	ErrorContext.instance().reset();	1✔
94	}
95	}
96	}	1✔
97
98	@Override
99	public T getObject() throws Exception {
100	return getSqlSession().getMapper(this.mapperInterface);	1✔
101	}
102
103	@Override
104	public Class<T> getObjectType() {
105	return this.mapperInterface;	1✔
106	}
107
108	@Override
109	public boolean isSingleton() {
110	return true;	1✔
111	}
112
113	// ------------- mutators --------------
114
115	/**
116	* Sets the mapper interface of the MyBatis mapper
117	*
118	* @param mapperInterface
119	* class of the interface
120	*/
121	public void setMapperInterface(Class<T> mapperInterface) {
122	this.mapperInterface = mapperInterface;	1✔
123	}	1✔
124
125	/**
126	* Return the mapper interface of the MyBatis mapper
127	*
128	* @return class of the interface
129	*/
130	public Class<T> getMapperInterface() {
131	return mapperInterface;	1✔
132	}
133
134	/**
135	* If addToConfig is false the mapper will not be added to MyBatis. This means it must have been included in
136	* mybatis-config.xml.
137	* <p>
138	* If it is true, the mapper will be added to MyBatis in the case it is not already registered.
139	* <p>
140	* By default addToConfig is true.
141	*
142	* @param addToConfig
143	* a flag that whether add mapper to MyBatis or not
144	*/
145	public void setAddToConfig(boolean addToConfig) {
146	this.addToConfig = addToConfig;	1✔
147	}	1✔
148
149	/**
150	* Return the flag for addition into MyBatis config.
151	*
152	* @return true if the mapper will be added to MyBatis in the case it is not already registered.
153	*/
154	public boolean isAddToConfig() {
155	return addToConfig;	1✔
156	}
157	}

mybatis / spring / 1949

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous