MyBatis框架入门
MyBatis的概述
1.框架：整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法。框架封装了很多的细节，使开发者使用极简的方式实现功能，大大提高开发效率。
2.三层架构：表现层，业务层，持久层
表现层：用于展示数据
业务层：处理业务需求
持久层：和数据库交互
3.持久层的解决方案
JDBC技术：Connection，PreparedStatement，ResultSet；
Spring的JdbcTemplate:Spring中对JDBC的简单封装；
Apache的DBUtils：JDBC的简单封装；
JDBC是规范，Spring的JdbcTemplate和DBUtils都只是对JDBC的简单封装，都不是框架。
持久层框架：MyBatis
概述：
Mybatis是一个优秀的基于Java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动，创建连接，创建statement等繁杂的过程。
MyBatis通过xml或注解的方式将要执行的各种statement配置起来，并通过Java对象和statement中sql的动态参数进行映射生成最终执行的sql语句，最后由MyBatis框架执行sql并将结果映射为Java对象并返回。
采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc-api底层访问细节，使我们不用与jdbc-api打交道，就可以完成对数据库的操作。
ORM（Object Relational Mapping）对象关系映射：把数据库表和实体类以及实体类的属性对应起来，让我们可以操作实体类就实现操作数据库表。
国内目前情况使用MyBatis的公司比Hibernate要多；
JDBC存在的问题：
1.频繁创建连接，十分消耗资源；
2.sql语句硬编码，修改起来十分不便，后期维护较为麻烦
3.获取结果集麻烦
MyBatis的环境搭建
1.导入依赖的jar包;
2.配置sqlMapConfig.xml，创建一个source folder放置配置文件。
SqlMapConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
<environment id="test">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
</environments>
</configuration>
1.<environments default=“development”>:default属性指定当前使用哪套配置环境。
3.配置log4j.properties;
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
4.复制pojo到工程目录下；
5.配置sql查询的映射文件
如user.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">
<!-- namespace 命名空间，相当于Java里面包的概念，用于区别sql语句 -->
<mapper namespace="user">
</mapper>
6.加载映射文件。
在SqlMapConfig.xml中的<environments>节点内写入以下内容：
<!-- 配置加载映射文件 -->
<mappers>
<mapper resource="mybatis/user.xml"/>
</mappers>
MyBatis入门案例
用户需求
根据用户id查询用户信息
1.编写sql语句
<?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">
<!-- namespace 命名空间，相当于Java里面包的概念，用于区别sql语句
#{}:占位符，相当于jdbc的问号。
-->
<mapper namespace="user">
<!-- id:sql id,语句的唯一标识
parameterType:入参的数据类型
resultType:返回结果的数据类型
-->
<select id="getUserById" parameterType="int" resultType="com.nikehu.mybatis.pojo.User">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`
FROM
`mybatis01`.`user`
WHERE id = #{id}
</select>
</mapper>
2.配置user映射文件
3.编写测试程序
package com.nikehu.mybatis.test;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import com.nikehu.mybatis.pojo.User;
public class MyBatisTest {
@Test
public void testGetUserById() throws IOException{
//加载配置文件
//创建一个SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
//创建一个核心配置文件的输入流对象
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//通过输入流创建SqlSessionFactory对象
SqlSessionFactory factory = ssfb.build(is);
//创建SqlSession对象，这个对象包含了对数据库表的CRUD操作；
SqlSession sqlSession = factory.openSession();
//查询一条记录，第一个参数为sql id，第二个参数为sql语句中的入参
User user = sqlSession.selectOne("user.getUserById",1);
System.out.println(user);
//释放资源
sqlSession.close();
}
}
根据用户名查找用户列表
@Test
public void testGetUserByName() throws IOException{
//加载配置文件
//创建一个SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
//创建一个核心配置文件的输入流对象
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//通过输入流创建SqlSessionFactory对象
SqlSessionFactory factory = ssfb.build(is);
//创建SqlSession对象，这个对象包含了对数据库表的CRUD操作；
SqlSession sqlSession = factory.openSession();
//查询一条记录，第一个参数为sql id，第二个参数为sql语句中的入参
List<User> uList = sqlSession.selectList("user.getUserByName","%张%");
System.out.println(uList);
//释放资源
sqlSession.close();
}
抽取工具类
com.nikehu.mybatis.util.SqlSessionFactoryUtils.java
package com.nikehu.mybatis.util;
import java.io.IOException;
import java.io.InputStream;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
/**
* 这是SqlSessionFactory工具类
* @author 猪猪
*
*/
public class SqlSessionFactoryUtils {
private static SqlSessionFactory sqlSessionFactory;
static{
try {
//创建一个SqlSessionFactoryBuilder对象
SqlSessionFactoryBuilder ssfb = new SqlSessionFactoryBuilder();
//创建一个核心配置文件的输入流对象
InputStream is = Resources.getResourceAsStream("SqlMapConfig.xml");
//通过输入流创建SqlSessionFactory对象
sqlSessionFactory = ssfb.build(is);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
/**
* 获取 SqlSessionFactory
* @return
*/
public static SqlSessionFactory getSqlSessionFactory() {
return sqlSessionFactory;
}
}
${}:字符串拼接指令，如果入参为普通数据类型，大括号内只能写value；
<!-- resultType 如果返回结果为集合时，只需设置为集合内元素对象的类型 -->
<select id="getUserByName" parameterType="string" resultType="com.nikehu.mybatis.pojo.User">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`
FROM
`mybatis01`.`user`
<!-- WHERE username LIKE #{name} -->
WHERE username LIKE '%${ value }%'
</select>
@Test
public void testGetUserByName02(){
SqlSessionFactory ssf = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession sqlSession = ssf.openSession();
List<User> uList = sqlSession.selectList("user.getUserByName","小");
System.out.println(uList);
//释放资源
sqlSession.close();
}
用户的增，删，该操作
添加用户
<!-- 插入用户 -->
<insert id="insertUser" parameterType="com.nikehu.mybatis.pojo.User">
INSERT INTO `mybatis01`.`user` (
`username`,
`birthday`,
`sex`,
`address`
)
VALUES
(
#{ username },
#{ birthday },
#{ sex },
#{ address }
) ;
</insert>
手动提交事务
@Test
public void testInsertUser(){
SqlSessionFactory ssf = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession sqlSession = ssf.openSession();
User user = new User();
user.setUsername("胡卫平");
user.setSex("1");
user.setAddress("江西吉安");
user.setBirthday(new Date());
sqlSession.insert("user.insertUser",user);
//提交事务
sqlSession.commit();
sqlSession.close();
}
设置SqlSession事务自动提交
SqlSession sqlSession = ssf.openSession(true);
添加用户返回主键
SELECT LAST_INSERT_ID();//查询最后一次插入的id，与会话有关
<!-- 插入用户 -->
<insert id="insertUser" parameterType="com.nikehu.mybatis.pojo.User">
<!-- selectKey:主键返回
keyProperty:user中的主键属性
resultType：主键的数据类型
order：指定selectKey何时执行，AFTER之后，BEFORE之前
-->
<selectKey keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID()
</selectKey>
INSERT INTO `mybatis01`.`user` (
`username`,
`birthday`,
`sex`,
`address`
)
VALUES
(
#{ username },
#{ birthday },
#{ sex },
#{ address }
) ;
</insert>
@Test
public void testInsertUser(){
SqlSessionFactory ssf = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession sqlSession = ssf.openSession(true);
User user = new User();
user.setUsername("宝贝");
user.setSex("2");
user.setAddress("陕西西安");
user.setBirthday(new Date());
int in = sqlSession.insert("user.insertUser",user);
//in 数据库影响的行数
System.out.println(user);
//提交事务
//sqlSession.commit();
sqlSession.close();
}
返回主键的简便设置
<!-- 插入用户返回主键的简便设置
useGeneratedKeys="true"使用自增，keyProperty与之配套使用，这里时user的主键
-->
<insert id="insertUser" parameterType="com.nikehu.mybatis.pojo.User" useGeneratedKeys="true" keyProperty="id">
INSERT INTO `mybatis01`.`user` (
`username`,
`birthday`,
`sex`,
`address`
)
VALUES
(
#{ username },
#{ birthday },
#{ sex },
#{ address }
) ;
</insert>
SELECT UUID();//可作为唯一标识
<!-- 插入用户设置UUID唯一标识 -->
<insert id="insertUserUUID" parameterType="com.nikehu.mybatis.pojo.User" useGeneratedKeys="false" keyProperty="id" >
<selectKey keyProperty="uuid2" resultType="String" order="BEFORE">
SELECT UUID()
</selectKey>
INSERT INTO `mybatis01`.`user` (
`username`,
`birthday`,
`sex`,
`address`,
`uuid2`
)
VALUES
(
#{ username },
#{ birthday },
#{ sex },
#{ address },
#{ uuid2 }
) ;
</insert>
更新用户和删除用户
<!-- 更新用户 -->
<update id="updateUser" parameterType="com.nikehu.mybatis.pojo.User">
UPDATE
`user`
SET
`username` = #{ username }
WHERE `id` = #{ id } ;
</update>
<!-- 删除用户 -->
<delete id="deleteUser" parameterType="int">
DELETE
FROM
`user`
WHERE `id` = #{ id } ;
</delete>
@Test
public void testUpdateUser(){
SqlSessionFactory ssf = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession openSession = ssf.openSession();
User user = new User();
user.setId(32);
user.setUsername("码字");
openSession.update("user.updateUser", user);
openSession.commit();
openSession.close();
}
@Test
public void testDeleteUser(){
SqlSessionFactory ssf = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession sqlSession = ssf.openSession();
sqlSession.delete("user.deleteUser",16);
sqlSession.commit();
sqlSession.close();
}
自定义MyBatis框架
MyBatis架构体系
传统DAO包装
原始DAO开发
使用原有的user映射文件，不需修改
UserDao.java
package com.nikehu.mybatis.dao;
import java.util.List;
import com.nikehu.mybatis.pojo.User;
/**
* 用户信息持久化接口
* @author 猪猪
* 1.根据用户ID查询用户信息
* 2.根据用户名查找用户列表
* 3.添加用户
*/
public interface UserDao {
/**
* 根据用户id查找用户信息
* @param id
* @return
*/
User getUserById(Integer id);
/**
* 根据用户名查找用户列表
* @param name
* @return
*/
List<User> getUsersByName(String name);
/**
* 添加用户
* @param user
*/
void insertUser(User user);
}
UserDaoImpl.java
package com.nikehu.mybatis.dao.impl;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import com.nikehu.mybatis.dao.UserDao;
import com.nikehu.mybatis.pojo.User;
import com.nikehu.mybatis.util.SqlSessionFactoryUtils;
/**
* 用户信息持久化实现类
* @author 猪猪
*
*/
public class UserDaoImpl implements UserDao{
@Override
public User getUserById(Integer id) {
SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
User user = openSession.selectOne("user.getUserById", id);
openSession.close();
return user;
}
@Override
public List<User> getUsersByName(String name) {
SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
List<User> uList = openSession.selectList("user.getUserByName", name);
openSession.close();
return uList;
}
@Override
public void insertUser(User user) {
SqlSessionFactory sqlSessionFactory = SqlSessionFactoryUtils.getSqlSessionFactory();
SqlSession openSession = sqlSessionFactory.openSession();
openSession.insert("user.insertUser", user);
openSession.commit();
openSession.close();
}
}
UserDaoTest.java
package com.nikehu.mybatis.test;
import static org.junit.Assert.*;
import java.util.Date;
import java.util.List;
import org.junit.Test;
import com.nikehu.mybatis.dao.UserDao;
import com.nikehu.mybatis.dao.impl.UserDaoImpl;
import com.nikehu.mybatis.pojo.User;
public class UserDaoTest {
@Test
public void testGetUserById() {
UserDao dao = new UserDaoImpl();
User user = dao.getUserById(33);
System.out.println(user);
}
@Test
public void testGetUsersByName() {
UserDao dao = new UserDaoImpl();
List<User> users = dao.getUsersByName("小");
System.out.println(users);
}
@Test
public void testInsertUser() {
UserDao dao = new UserDaoImpl();
User user = new User();
user.setUsername("明明");
user.setAddress("湖北武汉");
user.setBirthday(new Date());
user.setSex("1");
dao.insertUser(user);
}
}
接口动态代理DAO开发
动态代理dao开发规则
1.namespace必须是接口的全路径；
2.接口的方法名必须与映射文件的sql id一致；
3.接口的输入参数必须与映射文件的parameterType一致；
4.接口的返回类型必须与映射文件的resultType一致。
动态代理dao开发步骤
1.创建UserMapper.xml映射文件（把原来的user.xml复制按开发规则需求修改一下）；
2.创建UserMapper接口 (把原来的UserDao.java复制按开发规则需求修改一下)；
3.加载UserMapper.xml.
SqlMapConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
<environment id="test">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
</environments>
<!-- 配置加载映射文件 -->
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
</configuration>
UserMapper.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">
<!-- namespace 命名空间，相当于Java里面包的概念，用于区别sql语句
#{}:占位符，相当于jdbc的问号。
-->
<mapper namespace="com.nikehu.mybatis.mapper.UserMapper">
<!-- id:sql id,语句的唯一标识
parameterType:入参的数据类型
resultType:返回结果的数据类型
-->
<select id="getUserById" parameterType="int" resultType="com.nikehu.mybatis.pojo.User">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`
FROM
`mybatis01`.`user`
WHERE id = #{id}
</select>
<!-- resultType 如果返回结果为集合时，只需设置为集合内元素对象的类型 -->
<select id="getUserByName" parameterType="string" resultType="com.nikehu.mybatis.pojo.User">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`
FROM
`mybatis01`.`user`
<!-- WHERE username LIKE #{name} -->
WHERE username LIKE '%${ value }%'
</select>
<!-- 插入用户 -->
<insert id="insertUser" parameterType="com.nikehu.mybatis.pojo.User" useGeneratedKeys="true" keyProperty="id">
INSERT INTO `mybatis01`.`user` (
`username`,
`birthday`,
`sex`,
`address`
)
VALUES
(
#{ username },
#{ birthday },
#{ sex },
#{ address }
) ;
</insert>
</mapper>
UserMapper.java
package com.nikehu.mybatis.mapper;
import java.util.List;
import com.nikehu.mybatis.pojo.User;
/**
* 用户信息持久化接口
* @author 猪猪
* 1.根据用户ID查询用户信息
* 2.根据用户名查找用户列表
* 3.添加用户
*/
public interface UserMapper {
/**
* 根据用户id查找用户信息
* @param id
* @return
*/
User getUserById(Integer id);
/**
* 根据用户名查找用户列表
* @param name
* @return
*/
List<User> getUserByName(String name);
/**
* 添加用户
* @param user
*/
void insertUser(User user);
}
UserMapperTest.java
package com.nikehu.mybatis.test;
import static org.junit.Assert.*;
import java.util.Date;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import com.nikehu.mybatis.mapper.UserMapper;
import com.nikehu.mybatis.pojo.User;
import com.nikehu.mybatis.util.SqlSessionFactoryUtils;
public class UserMapperTest {
@Test
public void testGetUserById() {
SqlSession openSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
UserMapper mapper = openSession.getMapper(UserMapper.class);
User user = mapper.getUserById(34);
System.out.println(user);
openSession.close();
}
@Test
public void testGetUserByName() {
SqlSession openSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
UserMapper mapper = openSession.getMapper(UserMapper.class);
List<User> users = mapper.getUserByName("小");
System.out.println(users);
openSession.close();
}
@Test
public void testInsertUser() {
SqlSession openSession = SqlSessionFactoryUtils.getSqlSessionFactory().openSession();
UserMapper mapper = openSession.getMapper(UserMapper.class);
User user = new User();
user.setUsername("独孤求败");
user.setSex("1");
user.setAddress("湖南长沙");
user.setBirthday(new Date());
mapper.insertUser(user);
openSession.commit();
openSession.close();
}
}
属性加载
核心配置文件SqlMapConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
<environment id="test">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
</environments>
<!-- 配置加载映射文件 -->
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
</configuration>
properties(属性)：抽取属性
<configuration>
<properties>
<property name="jdbc.username" value="root"/>
<property name="jdbc.password" value="971102"/>
</properties>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
<environment id="test">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
</environments>
<!-- 配置加载映射文件 -->
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
</configuration>
将属性抽取到一个属性文件中jdbc.properties(先加载内部标签，在加载外部文件，属性名称一致时，会替换内容)；
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8
jdbc.username=root
jdbc.password=971102
<configuration>
<properties resource="jdbc.properties">
<property name="jdbc.username" value="root"/>
<property name="jdbc.password" value="971102"/>
</properties>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}" />
<property name="url"
value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</dataSource>
</environment>
<environment id="test">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis01?characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="971102" />
</dataSource>
</environment>
</environments>
<!-- 配置加载映射文件 -->
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
</configuration>
settings(全局配置参数):
typeAliases(别名):
别名配置
<typeAliases>
<!-- 单个别名的定义 -->
<typeAlias type="com.nikehu.mybatis.pojo.User" alias="user"/>
</typeAliases>
多个别名的配置方式：包扫描
<typeAliases>
<!-- 多个别名的定义：包扫描 -->
<package name="com.nikehu.mybatis.pojo"/>
</typeAliases>
定义好别名后就能直接在map.xml中使用，注意：别名的使用不严格区分大小写，当使用了包扫描（推荐）后，别名默认就是类的名称。不区分大小写。
typehandler(类型处理器)：
objectFactory(对象工厂):
plugins(插件):
environments(环境集合属性对象):
environment(环境子属性对象):
transactionManager(事务管理):
dataSource(数据源):
mappers(映射器):加载映射文件
映射文件加载
<mappers>
<mapper resource="mybatis/UserMapper.xml"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
<mappers>
<!-- 映射文件 class扫描器：
1.接口文件必须与映射文件同一目录下
2.接口文件的名称必须与映射文件的名称一致
-->
<mapper class="com.nikehu.mybatis.mapper.UserMapper"/>
<mapper resource="mybatis/user.xml"/>
</mappers>
多个映射文件的配置：包扫描（推荐）
<mappers>
<!-- 映射文件包扫描
1.接口文件必须与映射文件同一目录下
2.接口文件的名称必须与映射文件的名称一致
-->
<package name="com.nikehu.mybatis.mapper"/>
</mappers>
1620
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
