mybatis第一天——入门与概述

　　大纲摘要：

　　　　1、mybatis的介绍

　　　　2、Mybatis的入门

　　　　　　a) 使用jdbc操作数据库存在的问题

　　　　　　b) Mybatis的架构

　　　　　　c) Mybatis的入门程序

　　　　3、Dao的开发方法

　　　　　　a) 原始dao的开发方法——由ibatis遗留下来的

　　　　　　b) mapper动态代理方式

　　　　4、SqlMapConfig.xml文件说明

一、mybatis概述　

　　　　MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

　　2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，

　　而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

　　　　Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatement、CallableStatement）配置起来，

　　并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

　　　　是一个不完全的orm框架

　　根据经典的凡技术必登其官网的结论，官网文档很有必要参阅：http://www.mybatis.org/mybatis-3/zh/index.html

二、mybatis入门

【更新】 问题总结

　　　　1、 在创建连接时，存在硬编码

　　　　　　配置文件（全局配置文件）

　　　　2、 在执行statement时存在硬编码

　　　　　　配置文件（映射文件）

　　　　3、 频繁的开启和关闭数据库连接，会造成数据库性能下降。

　　　　　　数据库连接池（全局配置文件）

　　很多硬编码，把程序写死了！

　　1.mybatis架构

　　

　　详细架构请参见：http://blog.csdn.net/luanlouis/article/details/40422941

//SqlSession本身只是一个接口，它依靠executor进行执行增删改查操作

三.入门程序

　　导包：在github上下载mybatis,下载地址：

　　　　https://github.com/mybatis/mybatis-3/releases

　　　　包的结构如下：

　　导入的包如下图所示：

　　

　　引入核心jar包以及lib目录的下的依赖包

　　引入Mysql驱动包（持久层框架需要连接数据库都必须 必须导入驱动包！！！）

　　引入junit包（eclipse引入方法见另外一篇随笔）

　　创建核心配置文件——（全局配置文件）

　　新建一个与src同级的 source folder( maven的目录结构) 新建  SqlMapConfig.xml （约定大于配置，尽量不要修改名称）

　　（实际开发时会与spring进行整合，配置文件会有改动）

<?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/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
</configuration>

//ps:每次新建xml文件，第一件事应该是引入约束

　　引入log4j.properties——这是从官方文档中PDF中拿的（官方文档的查阅有待加强）

# 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

　　创建POJO类 User.java

package cn.pojo;

import java.util.Date;

public class User {
    private int id;
    private String username;// 用户姓名
    private String sex;// 性别
    private Date birthday;// 生日
    private String address;// 地址

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "User [id=" + id + ", username=" + username + ", sex=" + sex
                + ", birthday=" + birthday + ", address=" + address + "]";
    }

}

　　创建Sql映射文件 User.xml ——此命名方式是ibatis遗留下来的

<?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命名空间，用来作SQL隔离 -->
<mapper namespace="test">
    <!-- id为SQL:语句唯一标识
        parameterType:指定入参类型,java的类型而不是数据库的类型
        resultType：指定返回结果集类型（如 POJO类型）
        #{}是占位符，起到占位作用（不使用之前的?）#{中的变量名称可以随意写(当然尽量遵循规范)}
    -->
    <select id="findById" parameterType="java.lang.Integer" resultType="cn.pojo.User">
        select * from user where id = #{id}
    </select>
    <!-- 按姓名查询，
        返回的是集合类型 ,resultType里写的是selectList返回的集合里的泛型
        ${}原样拼接字符 传参是基本数据类型(包括String)里面变量名必须是value
        拼接符有SQL注入的风险，慎用 一般like的地方用拼接
         -->
    <select id="findByName" parameterType="java.lang.String" resultType="cn.pojo.User">
        select * from user where username like '%${value}%';
    </select>
</mapper>

　//一般而言不要直接在映射文件直接写SQL，在navicat等数据库管理工具写完做简单验证后再写回来

　　　　无论返回值是单个或者集合，returnType表示的是返回集合时集合泛型里的泛型

　　　加载映射文件

<?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/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="root" />
            </dataSource>
        </environment>
    </environments>
    <!-- 引入映射文件 -->
    <mappers>
        <mapper resource="User.xml"/>
    </mappers>
</configuration>

　　查询：

　　测试函数：

package mybatis01;

import java.io.InputStream;
import java.util.List;

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 cn.pojo.User;

public class UserTest {

    @Test
    public void findById() throws Exception{
        //通过流将核心配置文件进行读取（注意resources的所在包）
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //通过核心配置文件输入流来创建工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //通过工厂创建会话
        SqlSession session = factory.openSession();
        /*执行查询操作
         * 第一个参数为SQL语句 namespace+sql语句id格式
         * 第二个参数为SQL参数
         */
        User user = session.selectOne("test.findById", 1);
        System.out.println(user.toString());
        session.close();
    }
    @Test
    public void findByName() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        List<User> list = session.selectList("test.findByName", "王");
        System.out.println(list);

    }
}

　　//通过Resource获取核心配置文件到流里面

　　　　SQL模糊匹配规则如下：

　　　　　　% ：表示任意0个或多个字符。可匹配任意类型和长度的字符，有些情况下若是中文，请使用两个百分号（%%）表示。

　　　　　　_ ： 表示任意单个字符。匹配单个任意字符，它常用来限制表达式的字符长度语句：

　　　　　　[ ]（[^]同理） ：表示括号内所列字符中的一个（类似正则表达式）。指定一个字符、字符串或范围，要求所匹配对象为它们中的任一个。

　　小结：　

　　　　1 #{}和${}

　　　　#{}表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。

　　#{}可以接收简单类型值或pojo属性值。 如果parameterType传输单个简单类型值，#{}括号中可以是value或其它名称。

　　　　${}表示拼接sql串，通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，直接原样输出 ${}可以接收简单类型值或pojo属性值，常用于排序后面的动态列等。

　　　　其中，#是表示预编译的SQL，其SQL会在解析时解析为 ?（SELECT * FROM user WHERE id = ?），然后在DBMS阶段进行替换。

　　　　　　　$是仅在动态解析SQL时便进行替换，也就是说SQL解析之后均为常量

　　　　　　一般$用于传递表名、字段名、ORDER BY排序字段后等

　　如果　parameterType传输单个简单类型值，${}括号中只能是value。（防SQL注入见文末今日小结）

　　　　类似于一个是state，一个是pstate，占位符就相当于 ? 

　　　　更多相关见今日小结

　　　　2 parameterType和RessultType

　　parameterType：指定输入参数类型，mybatis通过ognl从输入对象中获取参数值拼接在sql中。

　　resultType：指定输出结果类型，mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。

　　　　3 selectOne和selectList

　　selectOne查询一条记录，如果使用selectOne查询多条记录则抛出异常：

　　　　org.apache.ibatis.exceptions.TooManyResultsException: Expected one result (or null) to be returned by selectOne(), but found: 3

　　at org.apache.ibatis.session.defaults.DefaultSqlSession.selectOne(DefaultSqlSession.java:70)

　　selectList可以查询一条或多条记录

　　增加

　　修改映射文件，增加相关的配置

<!-- insert无返回值类型，入参是整个实体类
        入参是POJO类型，#{}中的变量名必须属性，属性，...
    -->
    <!-- 如果要返回数据库自增主键，可以使用数据库的函数进行查询SELECT LAST_INSERT_ID() -->
    <insert id="insertUser" parameterType="cn.pojo.User">
        <!-- 执行数据库函数，返回自增主键
            keyProperty:将返回的主键保存在入参的user的id里
            order:在insert前执行是ibefore 在insert后执行是after
        -->
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            SELECT LAST_INSERT_ID()
        </selectKey>
        insert into user(username,sex,birthday,address) values(#{username},#{sex},#{birthday},#{address})
    </insert>

//原理是使用的OGNL对象图导航语言

　　测试函数：

@Test
    public void insert() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        User user = new User();
        user.setUsername("老李");
        //util下的Date
        user.setBirthday(new Date());
        user.setSex("1");
        user.setAddress("北京");
        session.insert("test.insertUser", user);
        //提交事务(会自动开启事务)，必须提交，否则运行成功后数据也无法插入到数据库
        session.commit();
　　　　　//传的是对象的引用，此时get到的是最新的插入的ID，因为通过配置进行了保存
        System.out.println(user.getId());
    }

　//注意事务的部分，增删改需要手动的提交事务！（openSession()的时候默认开启了事务，此方法有重载方法，参数为bool值，可以设置为true以设置不开启事务），不提交是不会更新到数据库的

　小结：

　　添加selectKey实现将主键返回：必须和insert语句一起使用

　　　　keyProperty:返回的主键存储在pojo中的哪个属性

　　　　order：selectKey的执行顺序，是相对与insert语句来说，由于mysql的自增原理执行完insert语句之后才将主键生成，

　　　　　　　　　　　　所以这里selectKey的执行顺序为after

　　　　resultType:返回的主键是什么类型

　　　　LAST_INSERT_ID():是mysql的函数，返回auto_increment自增列新记录id值

　　当使用 UUID 作为主键时：需要增加通过select uuid() （函数）得到uuid值

<insert  id="insertUser" parameterType="cn.itcast.mybatis.po.User">

<selectKey resultType="java.lang.String" order="BEFORE"

keyProperty="id">

select uuid()

</selectKey>

insert into user(id,username,birthday,sex,address)

 values(#{id},#{username},#{birthday},#{sex},#{address})

</insert>

//注意这里使用的order是“BEFORE”

　//此时使用的ID是通过我们生成进行插入的，所以首先需要在插入时显式的指定给ID赋值，因为该ID不是通过自增生成的 （VALUES(#{id}) ）

　//此时的SELECT UUID()函数会自动将生成的UUID赋值给指定的ID值

　//由于接收的是POJO类型，所以#{}里面必须是属性值（注意${}必须是value）

　　删除

　　修改映射文件，增加相关的配置

<!-- 删除无返回值，占位符变量可自定义 -->
    <delete id="deleteById" parameterType="int">
        DELETE FROM user WHERE id = #{id}
    </delete>

　　测试函数：

@Test
    public void delete() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        session.delete("test.deleteById", 29);
        session.commit();
    }

　　//注意事务的提交

　　修改

　　　修改映射文件，增加相关的配置

<!-- 更新时注意入参是pojo类型，此时占位符变量必须是属性名！ -->
    <update id="updateById" parameterType="cn.pojo.User">
        UPDATE user SET username=#{username} WHERE id=#{id}
    </update>

　　测试函数：

@Test
    public void update() throws Exception{
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession session = factory.openSession();
        User user = new User();
        user.setId(28);
        user.setUsername("县长");
        //util下的Date
        user.setBirthday(new Date());
        user.setSex("1");
        user.setAddress("北京");
        session.delete("test.updateById", user);
        session.commit();
    }

　　//注意入参

 四、DAO的开发方法

　　1.原生的开发方式——接口+实现类模式

　　//也就是将test中的代码进行一些改动，加到Dao

　　定义接口：

package cn.dao;

import java.util.List;

import cn.pojo.User;

public interface UserDao {

    User findById(Integer id);
    List<User> findByUsername(String username);
}

　　定义实现类：

package cn.dao;

import java.util.List;

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

import cn.pojo.User;

public class UserDaoImpl implements UserDao {

    //构造方法注入factory
    private SqlSessionFactory factory;

    public UserDaoImpl(SqlSessionFactory factory) {
        this.factory = factory;
    }

    @Override
    public User findById(Integer id) {
        //session是线程不安全的，最佳使用是在方法体内
        SqlSession session = factory.openSession();
        return session.selectOne("test.findById", id);
    }

    @Override
    public List<User> findByUsername(String username) {
        //session是线程不安全的，最佳使用是在方法体内
        SqlSession session = factory.openSession();
        return session.selectList("test.findByName", username);
    }

}

　　//使用构造方法注入factory的形式，因为不应该频繁地创建工厂，SqlSessionFactory生命周期应该是全局的单例的

　　//与spring整合后，交给spring来进行管理，所以这里用spring的非常熟悉的依赖注入（这里暂时使用构造注入） （而SqlSession有线程安全问题，无法进行单例的控制）

　　测试类：

package mybatis01;

import java.io.InputStream;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import cn.dao.UserDao;
import cn.dao.UserDaoImpl;
import cn.pojo.User;

public class UserDaoTest {

    private SqlSessionFactory factory;
    //在测试方法前会执行此初始化方法，构造工厂
    @Before
    public void setUp() throws Exception{
        //通过流将核心配置文件进行读取（注意resources的所在包）
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //通过核心配置文件输入流来创建工厂
        factory = new SqlSessionFactoryBuilder().build(in);
    }
    @Test
    public void test1() throws Exception{
        UserDao dao = new UserDaoImpl(factory);
        User user = dao.findById(1);
        System.out.println(user.toString());
    }
    @Test
    public void test2() throws Exception{
        UserDao dao = new UserDaoImpl(factory);
        List<User> list = dao.findByUsername("王");
        System.out.println(list);
    }
}

　　//注意before注解的使用

　　【更新】：问题引入：　　　　　

　　　　1、 有大量的重复的模板代码——例如获得sqlSession的过程，session的关闭

　　　 2、 存在硬编码

　　　　　　硬编码就是一种不够灵活的代码方案。
　　　　　　比如说，一个服务期端的程序，在执行时需要创建服务器进行侦听，你可以简单的将它需要侦听的端口号放在代码里面，

　　　　　　也可以通过程序参数传入，也可以通过配置文件放置。
　　　　　　上述的放在代码里面的就叫做硬编码

　　所以我们前面说的mapper里的命名空间不能随便写，后面它需要根据这个动态生成编码。前面一些模板代码都是重复的，里面的.selectOnde() .delete()等方法，里面需要传入的参数，第二个SQL参数由方法传入，所以就剩SQL的id，如果我们可以确定这个，那么就能实现了！

　　2.动态代理Dao的方式——只写接口，不写实现，由mybatis生成

　　　　mapper代理使用的是JDK的动态代理

【更新】：

　　　　1、 mapper接口的全限定名要和mapper映射文件的namespace值一致。

　　　　2、 mapper接口的方法名称要和mapper映射文件的statement的id一致。

　　　　3、 mapper接口的方法参数类型要和mapper映射文件的statement的parameterType的值一致，而且它的参数是一个。

　　　　4、 mapper接口的方法返回值类型要和mapper映射文件的statement的resultType的值一致。

　　1. Mapper.xml(映射文件) (内容类同User.xml)——配置文件与mapper命名一致且在同一目录下

<?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接口代理实现编写规则：
    1.映射文件中namespace要等于接口的全路径
    2.映射文件中sql语句的id要等于接口的方法名
    3.映射文件中传入参数类型要等于接口方法的入参
    4.映射文件返回值类型要等于接方法的返回值类型
     -->
<mapper namespace="cn.mapper.UserMapper">
    <!-- 不再赘述配置文件，详见User.xml -->
    <select id="findById" parameterType="java.lang.Integer" resultType="cn.pojo.User">
        select * from user where id = #{id}
    </select>
    <select id="findByName" parameterType="java.lang.String" resultType="cn.pojo.User">
        select * from user where username like '%${value}%';
    </select>
    <insert id="insertUser" parameterType="cn.pojo.User">
        <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
            SELECT LAST_INSERT_ID()
        </selectKey>
        insert into user(username,sex,birthday,address) values(#{username},#{sex},#{birthday},#{address})
    </insert>
</mapper>

　　//注意编写规则

　　2.mapper.java接口文件

package cn.mapper;

import java.util.List;

import cn.pojo.User;

public interface UserMapper {

    User findById(Integer id);
    //返回值是list集合时，mybatis会自动调用selectList()方法
    List<User> findByName(String username);
    void insertUser(User user);
}

　　//注意接口文件的编写规则（见配置文件注释）

　　看到not found的异常时应该想到：没把配置文件引入进核心配置文件！

<!-- 引入映射文件 -->
    <mappers>
        <mapper resource="User.xml"/>
        <!-- 使用class映入接口的全路径
            class的使用规则：
                1.接口名称和映射名称除拓展名外需要一致
                2.映射文件和接口在同一目录下
         -->
        <mapper class="cn.mapper.UserMapper"/>
    </mappers>

　　测试类：

package mybatis01;

import java.io.InputStream;
import java.util.Date;
import java.util.List;

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.Before;
import org.junit.Test;

import cn.mapper.UserMapper;
import cn.pojo.User;

public class UserMapperTest {

    private SqlSessionFactory factory;
    //在测试方法前会执行此初始化方法，构造工厂
    @Before
    public void setUp() throws Exception{
        //通过流将核心配置文件进行读取（注意resources的所在包）
        String resource = "SqlMapConfig.xml";
        InputStream in = Resources.getResourceAsStream(resource);
        //通过核心配置文件输入流来创建工厂
        factory = new SqlSessionFactoryBuilder().build(in);
    }
    @Test
    public void testFindById() throws Exception{
        SqlSession session = factory.openSession();
        //通过getMapper()方法实例化实现类
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.findById(1);
        System.out.println(user.toString());
    }
    @Test
    public void testFindByName() throws Exception{
        SqlSession session = factory.openSession();
        //通过getMapper()方法实例化实现类
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> list = mapper.findByName("王");
        System.out.println(list);
    }
    @Test
    public void insert() throws Exception{
        SqlSession session = factory.openSession();
        //通过getMapper()方法实例化实现类
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = new User();
        user.setUsername("宋江");
        user.setSex("2");
        user.setBirthday(new Date());
        user.setAddress("北京");
        mapper.insertUser(user);
        session.commit();
    }
}

//一定得注意提交！增加修改删除等是先改到缓存区的，所以必须提交！

五、SqlMapConfig.xml文件说明　

　　【更新】：详细配置讲解请参见：http://ju.outofmemory.cn/entry/94633

　　　　mybatis的配置文件主要分为

　　　　　　全局配置文件

　　　　　　　　　配置数据源、事务等全局信息

　　　　　　映射文件

　　　　　　　　执行statement相关的信息，SQL语句、输入输出映射等

　　SqlMapConfig.xml中配置的内容和顺序如下：

　　　　properties（属性）

　　　　settings（全局配置参数）

　　　　typeAliases（类型别名：给POJO类起别名）

　　　　typeHandlers（类型处理器）

　　　　objectFactory（对象工厂）

　　　　plugins（插件）——使用插件可以方便的进行分页等的操作

　　　　environments（环境集合属性对象）

　　　　　　environment（环境子属性对象）

　　　　　　　　transactionManager（事务管理）

　　　　　　　　dataSource（数据源）

　　　　mappers（映射器）

　　1 properties（属性）

　　SqlMapConfig.xml可以引用java属性文件（.properties）中的配置信息如下：

　　在classpath下定义db.properties文件（回忆key多加一层的原因：同在mybatis这个大容器中，容易发生命名冲突）

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

　　//如果jdbc.url多个参数需要使用&，请使用转义：&

　　SqlMapConfig.xml引用如下：(使用EL取值)

<properties resource="db.properties"/>
    <environments default="development">
        <environment id="development">
            <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>
    </environments>

　　2.支持别名

别名    映射的类型
_byte     byte
_long     long
_short     short
_int     int
_integer     int
_double     double
_float     float
_boolean     boolean
string     String
byte     Byte
long     Long
short     Short
int     Integer
integer     Integer
double     Double
float     Float
boolean     Boolean
date     Date
decimal     BigDecimal
bigdecimal     BigDecimal
map    Map

　　3.自定义别名：

　　在SqlMapConfig.xml中配置：

<typeAliases>
    <!-- 单个别名定义 -->
    <typeAlias alias="user" type="cn.itcast.mybatis.po.User"/>
    <!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->
    <package name="cn.itcast.mybatis.po"/>
    <package name="其它包"/>
</typeAliases>

　　//建议遵循驼峰式命名规则，批量别名时默认别名是类名（请使用规范首字母小写）

　　4.mappers（映射器）

　　1 <mapper resource=" " />

　　使用相对于类路径的资源

　　如：<mapper resource="sqlmap/User.xml" />

　　2. <mapper class=" " />

　　使用mapper接口类路径

　　如：<mapper class="cn.itcast.mybatis.mapper.UserMapper"/>

　　注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

　　3.<package name=""/> 包扫描的方式

　　　　使用的最多最简便，但是注意遵循相关的规则，与上述接口文件编写规则配置文件一致（映射文件与接口同名并且同一目录）

　　注册指定包下的所有mapper接口

　　如：<package name="cn.itcast.mybatis.mapper"/>

最后，贴出目录结构（夹带了一点day02的QueryVo等）

　　

//三个source folder，为的是实现maven的目录结构

　　今日小结：

　　1. mybatis是一个持久层框架, 作用是跟数据库交互完成增删改查
　　2.原生Dao实现(需要接口和实现类)
　　4.动态代理方式(只需要接口)
　　mapper接口代理实现编写规则:
　　　　1) 映射文件中namespace要等于接口的全路径名称
　　　　2) 映射文件中sql语句id要等于接口的方法名称
　　　　3) 映射文件中传入参数类型要等于接口方法的传入参数类型
　　　　4) 映射文件中返回结果集类型要等于接口方法的返回值类型

　　5. #{}占位符:占位
　　　　如果传入的是基本类型,那么#{}中的变量名称可以随意写
　　　　如果传入的参数是pojo类型,那么#{}中的变量名称必须是pojo中的属性.属性.属性...

　　6. ${}拼接符:字符串原样拼接
　　　　如果传入的是基本类型,那么${}中的变量名必须是value
　　　　如果传入的参数是pojo类型,那么${}中的变量名称必须是pojo中的属性.属性.属性...
　　　　注意:使用拼接符有可能造成sql注入,在页面输入的时候可以加入校验,不可输入sql关键字,不可输入空格
　　7. 映射文件:
　　　　1)传入参数类型通过parameterType属性指定
　　　　2)返回结果集类型通过resultType属性指定
　　8. hibernate和mybatis区别:
　　　　hibernate:它是一个标准的orm框架,比较重量级,学习成本高.
　　优点:高度封装,使用起来不用写sql,开发的时候,会减低开发周期.数据库无关性！
　　缺点:sql语句无法优化
　　应用场景:oa(办公自动化系统), erp(企业的流程系统)等,还有一些政府项目,
　　总的来说,在用于量不大,并发量小的时候使用.
　　　　mybatis:它不是一个orm框架, 它是对jdbc的轻量级封装, 学习成本低,比较简单
　　优点:学习成本低, sql语句可以优化, 执行效率高,速度快.【提高了SQL控制权！】
　　缺点:编码量较大,会拖慢开发周期
　　应用场景: 互联网项目,比如电商,P2p等
　　总的来说是用户量较大,并发高的项目.

　　【补充注意事项】：当出现无法完成绑定异常时，是由于只有.java文件被编译而xml文件未被编译，方法之一可以在pom.xml中加入resource标签：　　　

<build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
        <plugins>
            <!-- 配置Tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <configuration>
                    <port>8083</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>