mapperspackage_MyBatis 的mapperxml配置的问题

『壹』 SpringBoot集成Mybatis 找不到Mapper里的接口

mybatis 的springboot 集成项目已猛巧拆经发宽配布了
maven
12345<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.0.0</version></dependency>枝枣
properties 配置
123456mybatis.config= # mybatis config filemybatis.mapperLocations= # mappers filemybatis.typeAliasesPackage= # domain object's package mybatis.typeHandlersPackage= # handler's packagemybatis.check-config-location= # check the mybatis configuration existsmybatis.executorType= # mode of execution. Default is SIMPLE

『贰』如何通过接口查找对应的mapper.xml及方

在使用mybatis的时候，有一种方式是
BookMapper bookMapper = SqlSession().getMapper(BookMapper.class)
获取接口，然后茄森烂调用接口的方法。只要方法名和对应的mapper.xml中的id名字相同，就可以执行sql。
那么接口是如何与mapper.xml对应的呢？
首先看下，在getMapper()方法是如何操作的。
在DefaultSqlSession.java中调用了configuration.getMapper()
public <T> T getMapper(Class<T> type) {
return configuration.<T>getMapper(type, this);
}
在Configuration.java中调用了mapperRegistry.getMapper(type, sqlSession)；
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
下面重点来了，在MapperRegistry.java中实现了动态代理
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null)
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
这个函数分两部分来看，首先是从map集合中获取接口代理，map集合的来源，第二部分获取代理后实例春雹化，获取接口的方法，执行sql。
对于第一部分：集合的来源。
这颤漏个MapperRegistry.java中有个方法是addMappers();共有两个重载。
public void addMappers(String packageName, Class<?> superType) {
ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
//通过包名，查找该包下所有的接口进行遍历，放入集合中
resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
for (Class<?> mapperClass : mapperSet) {
addMapper(mapperClass);
}
}
//解析包名下的接口
public void addMappers(String packageName) {
addMappers(packageName, Object.class);
}
往上追溯该方法的调用是在SqlSessionFactory.build();时对配置文件的解析，其中对节点mappers的解析，这里先不赘述，
mapperElement(root.evalNode("mappers"));
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
//使用package节点进行解析配置
if ("package".equals(child.getName())) {
String mapperPackage = child.getStringAttribute("name");
//注册包下的接口
configuration.addMappers(mapperPackage);
} else {
//使用mapper节点
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
InputStream inputStream = Resources.getResourceAsStream(resource);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();
} else if (resource == null && url != null && mapperClass == null) {
ErrorContext.instance().resource(url);
InputStream inputStream = Resources.getUrlAsStream(url);
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
mapperParser.parse();
} else if (resource == null && url == null && mapperClass != null) {
Class<?> mapperInterface = Resources.classForName(mapperClass);
configuration.addMapper(mapperInterface);
} else {
throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
}
}
}
}
}
这是调用addMapper()的顺序。
同时在改方法中还有一个方法很重要
public <T> void addMapper(Class<T> type) {
if (type.isInterface()) {
if (hasMapper(type)) {
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
boolean loadCompleted = false;
try {
knownMappers.put(type, new MapperProxyFactory<T>(type));
//根据接口名寻找同包下同名的xml或者mapper的namespace是该接口的xml
//找到对用的xml后进行解析mapper节点里面的节点
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
parser.parse();
loadCompleted = true;
} finally {
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}
这是通过接口的全路径来查找对应的xml。这里有两种方式解析，也就是我们平常xml文件放置位置的两种写法。
第一种是不加namespace，把xml文件放在和接口相同的路径下，同时xml的名字与接口名字相同，如接口名为Student.java，xml文件为Student.xml。在相同的包下。这种当时可以不加namespace.
第二种是加namespace,通过namespace来查找对应的xml.
到这就是接口名和xml的全部注册流程。
下面再说下第二部分就是通过动态代理获取接口名字来对应xml中的id。
主要有两个类MapperProxyFactory.java和MapperProxy.java
对于MapperProxyFactory.java
public class MapperProxyFactory<T> {
private final Class<T> mapperInterface;
private Map<Method, MapperMethod> methodCache = new ConcurrentHashMap<Method, MapperMethod>();
//构造函数，获取接口类
public MapperProxyFactory(Class<T> mapperInterface) {
this.mapperInterface = mapperInterface;
}
public Class<T> getMapperInterface() {
return mapperInterface;
}
public Map<Method, MapperMethod> getMethodCache() {
return methodCache;
}
@SuppressWarnings("unchecked")
protected T newInstance(MapperProxy<T> mapperProxy) {
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
//供外部调用
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
return newInstance(mapperProxy);
}
}
在MapperProxy.java中进行方法的执行
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (Object.class.equals(method.getDeclaringClass())) { try { return method.invoke(this, args); } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } } final MapperMethod mapperMethod = cachedMapperMethod(method);
//方法的执行
return mapperMethod.execute(sqlSession, args);
}
private MapperMethod cachedMapperMethod(Method method) { MapperMethod mapperMethod = methodCache.get(method); if (mapperMethod == null) { mapperMethod = new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()); methodCache.put(method, mapperMethod); } return mapperMethod;
}
至此，就是mybatis所有接口和xml的加载，以及通过动态代理来进行接口的执行的过程。

『叁』如何配置mybatis开发环境

1、打开MyEclipse或者Eclipse，新建一个JavaProject项目mybatis

谢谢采纳

『肆』 mybatis怎么做联合查询

MyBatis之多表联合查询
在这篇文章里面主要讲解如何在mybatis里面使用一对一、一对多、多表联合查询（类似视图）操作的例子。
注：阅读本文前请先大概看一下之前两篇文章。
一、表结构
班级表class，学生表student，班级学生关系表ClassStudent。
这里一个学生只会在一个班级里面，也就是一对一的关系；一个班级有多个学生，也就是一对多的关系。
结构如下：

CREATE TABLE [dbo].[Class](
[class_id] [int] NOT NULL,
[class_name] [varchar](50) NOT NULL,
CONSTRAINT [PK_Class] PRIMARY KEY CLUSTERED
(
[class_id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

CREATE TABLE [dbo].[ClassStudent](
[class_id] [int] NOT NULL,
[student_id] [int] NOT NULL
) ON [PRIMARY]

CREATE TABLE [dbo].[Student](
[s_id] [int] NOT NULL,
[s_name] [varchar](50) NOT NULL,
CONSTRAINT [PK_Student] PRIMARY KEY CLUSTERED
(
[s_id] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

3张表的数据如下：

insert into Class values(1,'三(1)班')
insert into Class values(2,'三(2)班')
insert into Class values(3,'三(3)班')
insert into Class values(4,'三(4)班')

insert into Student values(1001,'张三')
insert into Student values(1002,'李四')
insert into Student values(1003,'赵五')
insert into Student values(1004,'王二麻子')

insert into ClassStudent values(1,1001)
insert into ClassStudent values(1,1003)
insert into ClassStudent values(4,1002)
insert into ClassStudent values(3,1004)

二、在原项目下新建一个包com.mybatis.sqljoinrelation，在包里面新建一个sqlMapper.xml的映射文件，在项目的mybatis的配置文件conf.xml中对这个sqlMapper.xml进行注册，注册片段如下：

<mappers>
<mapper resource="com/mybatis/sqljoinrelation/sqlMapper.xml" />
</mappers>

紧接着在原项目下再新建一个包com.mybatis.bean，在里面新建实体类
学生：

package com.mybatis.bean;

/**
* 学生(临时)
*/
public class StudentTemp {
private int studentid;
private String studentname;
private Class tempClass;

public Class getTempClass() {
return tempClass;
}
public void setTempClass(Class tempClass) {
this.tempClass = tempClass;
}
public int getStudentid() {
return studentid;
}
public void setStudentid(int studentid) {
this.studentid = studentid;
}
public String getStudentname() {
return studentname;
}
public void setStudentname(String studentname) {
this.studentname = studentname;
}

@Override
public String toString() {
return "StudentTemp [studentid=" + studentid + ", studentname="
+ studentname + ", tempClass=" + tempClass + "]";
}

}

班级：

package com.mybatis.bean;

/**
* 班级
*/
public class Class {
private int classid;
private String classname;

public int getClassid() {
return classid;
}
public void setClassid(int classid) {
this.classid = classid;
}
public String getClassname() {
return classname;
}
public void setClassname(String classname) {
this.classname = classname;
}

@Override
public String toString() {
return "Class [classid=" + classid + ", classname=" + classname + "]";
}
}

学生班级视图类：

package com.mybatis.bean;

public class studentclass {
private int s_id;
private String s_name;
private int class_id;
private String class_name;
public int getS_id() {
return s_id;
}
public void setS_id(int s_id) {
this.s_id = s_id;
}
public String getS_name() {
return s_name;
}
public void setS_name(String s_name) {
this.s_name = s_name;
}
public int getClass_id() {
return class_id;
}
public void setClass_id(int class_id) {
this.class_id = class_id;
}
public String getClass_name() {
return class_name;
}
public void setClass_name(String class_name) {
this.class_name = class_name;
}
@Override
public String toString() {
return "studentclass [s_id=" + s_id + ", s_name=" + s_name
+ ", class_id=" + class_id + ", class_name=" + class_name + "]";
}

}

三、查询操作
1、一对一，查询学生编号等于1001且他所在班级信息
2、一对多，查询班级编号等于1且包含所有学生信息
3、类似视图查询学生编号等于1001且他所在班级信息
sqlMapper.xml如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.sqljoinrelation.sqlMapper">



<select id="getStudentAndClass" parameterType="int" resultMap="studentClassMap">
select c.class_id,c.class_name,s.s_id,s.s_name
from Class c left join ClassStudent cs
on c.class_id = cs.class_id
left join Student s
on cs.student_id = s.s_id
where s.s_id = #{id}
</select>


<resultMap type="com.mybatis.bean.StudentTemp" id="studentClassMap">

<id property="studentid" column="s_id" />
<result property="studentname" column="s_name" />


<association property="tempClass" javaType="com.mybatis.bean.Class">

<id property="classid" column="class_id" />
<result property="classname" column="class_name" />
</association>
</resultMap>



<select id="getStudentAndClassView" parameterType="int" resultType="com.mybatis.bean.studentclass">
select c.class_id,c.class_name,s.s_id,s.s_name
from Class c left join ClassStudent cs
on c.class_id = cs.class_id
left join Student s
on cs.student_id = s.s_id
where s.s_id = #{id}
</select>


<select id="getClassStudents" parameterType="int" resultMap="classStudentsMap">
select *
from Class c left join ClassStudent cs
on c.class_id = cs.class_id
left join Student s
on cs.student_id = s.s_id
where c.class_id = #{id}
</select>
<resultMap type="com.mybatis.bean.ClassTemp" id="classStudentsMap">
<id property="classid" column="class_id"/>
<result property="classname" column="class_name"/>


<collection property="students" ofType="com.mybatis.bean.Student">
<id property="studentid" column="s_id"/>
<result property="studentname" column="s_name"/>
</collection>
</resultMap>
</mapper>

测试代码如下：
一对一与类似视图查询的代码在一起，如下：

package com.mybatis.sqljoinrelation;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import com.mybatis.util.MybatisUtils;

/**
* 一对一
*/
public class testonetoone {
public static void main(String[] args) {
SqlSessionFactory factory = MybatisUtils.getFactory();
SqlSession session = null;
try {
session = factory.openSession(true);

//1、StudentTemp
String statement1 = "com.mybatis.sqljoinrelation.sqlMapper.getStudentAndClass";
System.out.println(session.selectOne(statement1, 1001));

//2、用model类型接收数据
String statement2 = "com.mybatis.sqljoinrelation.sqlMapper.getStudentAndClassView";
System.out.println(session.selectOne(statement2, 1001));

} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
}
}

一对多测试代码如下：

package com.mybatis.sqljoinrelation;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import com.mybatis.util.MybatisUtils;

/**
* 一对多
*/
public class testonetomany {
public static void main(String[] args) {
SqlSessionFactory factory = MybatisUtils.getFactory();
SqlSession session = null;
try {
session = factory.openSession(true);

//1、StudentTemp
String statement = "com.mybatis.sqljoinrelation.sqlMapper.getClassStudents";
System.out.println(session.selectOne(statement, 1));

} catch (Exception e) {
e.printStackTrace();
}finally{
session.close();
}
}
}

四、sqlMapper.xml需要说明的问题
1、一对一：<association property="tempClass" javaType="com.mybatis.bean.Class">
association字面意思关联，这里只专门做一对一关联； property表示是com.mybatis.bean.StudentTemp中的属性名称； javaType表示该属性是什么类型对象
2、类似视图查询： <select id="getStudentAndClassView" parameterType="int" resultType="com.mybatis.bean.studentclass">
resultType 对应简单类型，也就是实体中的属性名称与数据库表字段名称一模一样；
resultMap 对应复杂类型，属性名称与字段名称不一样可以通过resultMap中property,column进行映射，其中一对一与一对多都是用resultMap来映射
3、一对多：<collection property="students" ofType="com.mybatis.bean.Student">
collection字面意思是集合，这里专门做一对多关联，property表示集合类型属性名称，ofType表示集合中的对象是什么类型
4、<select>select * from ...</student>与<select>select 字段1，字段2，字段3... from ...</student>
可以显示指出c.class_id,c.class_name,s.s_id,s.s_name列明，如果用"*"代替，则mybatis会自动匹配resultMap或者resultType中提供的列名，
如果某对象存在列映射的属性，但是在select 后面找不到这个列，则在返回结果中，该列多映射的值为null。

至此，对于一对一、一对多、视图查询都能很好的解决，主要还是要重点关注第四点说明。
------------------SB要封便封

『伍』 mybatis mapper接口，不同包下怎么配置

『陆』 mybatis报Mapper配置文件出错

最近学习mybatis框架时，遇到一坑，记录一下debug过程。

操作表一对一查询时，运行junit测试类时报错如下：

根据错误提示，第一时间检查了mapper的xml文件名称以及对应的包名是否跟接口类的一致，确认没有问题后，初步判定原因是 mapper映射文件问题 ，mapper内容如下：

随后检查mapper文件中返回类型以及实判升体类属性、数据表对掘尺老应字段，发现应该是由于resultMap定义的返回类型有问题，于是检查mybatis主配困誉置文件

果不其然，调试后明确问题：
由于主配置文件只配置了<mappers>标签下的<package>指定了接口所在包， 没有配置<typeAliases>下的<package>指定实体类的别名，因此mapper文件中返回的实体类名称不能使用简写，需要写完整全限定类名

主配置文件指定实体类别名后测试，测试类正常返回一对一查询的数据

『柒』 mybatis mapper.xml中怎么设置主键自动生成

一个配置完整的 settings 元素的示例如下：

<settings>
<setting name="cacheEnabled" value="true"/>
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="multipleResultSetsEnabled" value="true"/>
<setting name="useColumnLabel" value="true"/>
<setting name="useGeneratedKeys" value="false"/>
<setting name="autoMappingBehavior" value="PARTIAL"/>
<setting name="defaultExecutorType" value="SIMPLE"/>
<setting name="defaultStatementTimeout" value="25"/>
<setting name="safeRowBoundsEnabled" value="false"/>
<setting name="mapUnderscoreToCamelCase" value="false"/>
<setting name="localCacheScope" value="SESSION"/>
<setting name="jdbcTypeForNull" value="OTHER"/>
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

配置环境（environments）
MyBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中，现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者共享相同 Schema 的多个生产数据库，想使用相同的 SQL 映射。许多类似的用例。
不过要记住：尽管可以配置多个环境，每个 SqlSessionFactory 实例只能选择其一。
所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库闭歼，就需要三个实例，依此类推，记起来很简单：
每个数据库对应一个 SqlSessionFactory 实例
为了指定创建哪种环境，只要将它作为可选的参数传递给 SqlSessionFactoryBuilder 即可。可以接受环境配置的两个方法签名是：
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader, environment,properties);

如果忽略了环境参数，那么默认环境将会被加载，如谨滑下所示祥态腊：
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader);
SqlSessionFactory factory = sqlSessionFactoryBuilder.build(reader,properties);

Environments配置示例

<environments default="development">
<environment id="development">
<transactionManager type="JDBC">
<property name="..." value="..."/>
</transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>

<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/wifi?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull" />
<property name="username" value="root" />
<property name="password" value="123456" />
</dataSource>
</environment>
</environments>

注意这里的关键点:
默认的环境 ID（比如:default=”development”）。
每个 environment 元素定义的环境 ID（比如:id=”development”）。
事务管理器的配置（比如:type=”JDBC”）。
数据源的配置（比如:type=”POOLED”）。
默认的环境和环境 ID 是自我解释的。你可以使用你喜欢的名称来命名，只要确定默认的要匹配其中之一。
映射器（mappers）
既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要定义 SQL 映射语句了。但是首先我们需要告诉 MyBatis 到哪里去找到这些语句。Java 在自动查找这方面没有提供一个很好的方法，所以最佳的方式是告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 的 URL），或类名和包名等。例如：

<mappers>
<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
<mapper resource="org/mybatis/builder/BlogMapper.xml"/>
<mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<mappers>
<mapper url="file:///var/mappers/AuthorMapper.xml"/>
<mapper url="file:///var/mappers/BlogMapper.xml"/>
<mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<mappers>
<mapper class="org.mybatis.builder.AuthorMapper"/>
<mapper class="org.mybatis.builder.BlogMapper"/>
<mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<mappers>
<package name="org.mybatis.builder"/>
</mappers>

『捌』 spring 整合mybatis后若mapper.java与mapper.xml不在同一文件夹,该怎么配置

原因如下：

1、在mybatis的配置中，有些地方是可以省略的，如果你的mapper.xml文件和mapper.java文件，如果放到同一个文件夹中，就可以省略很多配置。

4、通过这个级别关系可以看出，resources和java是同一级别，而且，编译后的文件（见上图），都是同一个路径，所以，就可以把他拆分出来，所以，这样，即美观，又实用，配置又少。

『玖』 basepackage 怎么配置多个目录

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="mapperLocations">
<array>
<value>classpath:mapper/*.xml</value>
</array>
</property>
<property name="typeAliasesPackage" value="com.isea533.mybatis.model"/>
<property name="plugins">
<array>
<bean class="com.github.pagehelper.PageHelper">
<property name="properties">
<value>
dialect=hsqldb
reasonable=true
</value>
</property>
</bean>
<bean class="com.github.abel533.mapperhelper.MapperInterceptor">
<property name="properties">
<value>
mappers=com.github.abel533.mapper.Mapper
IDENTITY=MYSQL
notEmpty=true
</value>
</property>并盯枣
</bean>
</array>
</property>
</bean>

dataSource属性
该属性必须配置，多数据源时会有多个dataSource，同时也需要配置多个sqlSessionFactory来对应。
mapperLocations属性
配置该属性后，绝拆sqlSessionFactory会自动扫描该路径下的所有文件并解析。
该路径支持多个，可以用,;\t\n进行分割。
每一个路径都可以用直接的包路径，或者Ant风格的表达式。
configLocation属则昌性
上面例子中并没有使用该属性，当SqlSessionFactoryBean提供的配置不能满足使用时，你可以使用mybatis-config.xml配置文件配置其他属性，然后通过configLocation属性指定该配置的路径，SqlSessionFactoryBean会使用该配置文件创建Configuration。
typeAliasesPackage属性
该属性可以给包中的类注册别名，注册后可以直接使用类名，而不用使用全限定的类名（就是不用包含包名）。
该属性可以配置多个，可以用,;\t\n进行分割。但是不支持Ant风格的路径。
plugins属性
该属性可以配置MyBatis的拦截器，拦截器的配置顺序会影响拦截器的执行顺序。
从上往下的拦截器，实际的执行顺序是这样，第一个拦截器会最后执行，最后一个会首先执行。
然后出拦截器的顺序和配置的顺序一致，第一个最先返回，最后一个最后返回。

『拾』 MyBatis 的mapper.xml配置的问题

我们知道在Mybatis中定义Mapper信息有两种方式，一种是利用xml写一个对应的包含Mapper信息的配置文件；另一种就是定义一个Mapper接口，然后定义一些相应的操作方法，再辅以相应的操作注解。
现假设我有这样一个实体类：
Java代码收藏代码
package com.tiantian.mybatis.model;

public class User {

private int id;
private String name;
private int age;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}

它对应的数据库表结构是这样的：

然后我要利用Mybatis对它做一个简单的增删改查操作，那么如果利用xml配置Mapper的方式来定义的话，我对应的UserMapper.xml文件会是这样：
Xml代码收藏代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.tiantian.mybatis.mapper.UserMapper">
<insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyColumn="id">
insert into t_user(name, age) values(#{name}, #{age})
</insert>

<update id="updateUser" parameterType="User">
update t_user set name=#{name}, age=#{age} where id=#{id}
</update>

<select id="findById" parameterType="int" resultType="User">
select * from t_user where id=#{id}
</select>

<delete id="deleteUser" parameterType="int">
delete from t_user where id=#{id}
</delete>
</mapper>

如果使用接口加注解的方式，那么我们的UserMapper接口应该这样定义：
Java代码收藏代码
package com.tiantian.mybatis.mapperinterface;

import org.apache.ibatis.annotations.Delete;
import or www.hbbz08.com g.apac he.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.tiantian.mybatis.model.User;

public interface UserMapper {

@Insert("insert into t_user(name, age) values(#{name}, #{age})")
public void insertUser(User user);

@Update("update t_user set name=#{name}, age=#{age} where id=#{id}")
public void updateUser(User user);

@Select("select * from t_user where id=#{id}")
public User findById(int id);

@Delete("delete from t_user where id=#{id}")
public void deleteUser(int id);

}

注意看这里我故意把UserMapper接口的namespace也就是它的包名置为与UserMapper.xml的namespace属性不一样。这主要是为了要更好的讲以下的内容。
接下来要做的就是把Mapper信息注册到Mybatis的配置中，告诉Mybatis我们定义了哪些Mapper信息。这主要是在Mybatis的配置文件中通过mappers元素来进行的。在以前版本的Mybatis中我们在Mybatis的配置文件中需要这样定义Mapper信息资源的位置。
Xml代码收藏代码
<mappers>
<mapper resource="com/tiantian/mybatis/mapper/UserMapper1.xml"/>
<mapper url="file:///E:/UserMapper.xml"/>
</mappers>

这主要是通过mapper元素的resource和url属性来指定的，resource属性指定的是相对于跟类路径下的资源，url属性指定的是通过URL可以获取到的资源。这有一点不好的地方，当我们使用Mapper接口加注解来定义当前Mapper的操作信息时，我们还需要定义一个与它对应的Mapper.xml文件。如：
Xml代码收藏代码
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tiantian.mybatis.mapperinterface.UserMapper">

</mapper>

导航:首页 > APP软件 > mapperspackage

mapperspackage

与mapperspackage相关的资料

友情链接