MyBatis框架——First Day

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法;另一种
定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义。  
简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。简单说就是使用别
人搭好的舞台，你来做表演。而且，框架一般是成熟的，不断升级的软件。

2.框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的 框架中，有着各种各样的技术，不同的
软件企业需要从 J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技
术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设
计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应
用的底层支撑，它不应该直接对应用产生影响。 
 
框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

3. 软件开发的分层重要性

框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现
软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的
MVC 软件设计思想就是很好的分层思想。

4.分层开发的常见框架

MyBatis 框架概述

mybatis 是一个优秀的基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，
而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程。 
mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中
sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并
返回。 
采用 ORM 思想解决了实体和数据库映射的问题，对 jdbc 进行了封装，屏蔽了 jdbc api 底层访问细节，使我
们不用与 jdbc api 打交道，就可以完成对数据库的持久化操作。 
为了我们能够更好掌握框架运行的内部过程，并且有更好的体验，下面我们将从自定义 Mybatis 框架开始来
学习框架。此时我们将会体验框架从无到有的过程体验，也能够很好的综合前面阶段所学的基础。

JDBC 编程的回顾

1.加载驱动
2.获取数据库连接对象
3.获取操作对象
4.编写SQL语句
5.执行SQL语句
6.遍历结果集，封装数据
7.释放资源

JDBC 问题分析

1、数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。 
2、Sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变 java
代码。 
3、使用 preparedStatement 向占有位符号传参数存在硬编码，因为 sql 语句的 where 条件不一定，可能
多也可能少，修改 sql 还要修改代码，系统不易维护。 
4、对结果集解析存在硬编码（查询列名），sql 变化导致解析代码变化，系统不易维护，如果能将数据库记
录封装成 pojo 对象解析比较方便。

MyBatis 框架快速入门

1.官网下载MyBatis框架jar包

 官网：http://www.mybatis.org/mybatis-3/zh/getting-started.html
 
 如果使用 Maven 来构建项目，则需将下面的 dependency 代码置于 pom.xml 文件中：

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.4.5</version>
</dependency>

2.搭建MyBatis 开发环境

1.创建普通的Maven工程
2.在 pom.xml 文件中添加 Mybatis3.4.5 的坐标，如下： 
  还要添加单元测试jar包，数据库驱动jar包，log4j日志jar包
 <dependencies> 
    <dependency> 
      <groupId>org.mybatis</groupId> 
      <artifactId>mybatis</artifactId> 
      <version>3.4.5</version> 
    </dependency> 
    <dependency> 
      <groupId>junit</groupId> 
      <artifactId>junit</artifactId> 
      <version>4.12</version> 
      <scope>test</scope> 
    </dependency> 
    <dependency> 
      <groupId>mysql</groupId> 
      <artifactId>mysql-connector-java</artifactId> 
      <version>5.1.6</version> 
      <scope>runtime</scope> 
    </dependency> 
    <dependency> 
      <groupId>log4j</groupId> 
      <artifactId>log4j</artifactId> 
      <version>1.2.12</version> 
    </dependency> 
  </dependencies> 
  
3.在 org.westos.domain 包下编写实体类
    public class User implements Serializable { 
 
    private Integer id; 
    private String username; 
    private Date birthday; 
    private String sex; 
    private String address; 
     //get set 方法略 自己补上
  }
  
4.在org.westos.dao 包下编写接口 IUserDao 
IUserDao 接口就是我们的持久层接口（也可以写成 UserDao 或者 UserMapper）,具体代码如下： 

public interface IUserDao {
    //查询所有用户
    List<User> findAll();
}

3. 编写持久层接口的映射文件 IUserDao.xml

1.要求： 
  创建位置：必须和持久层接口在相同的包中。 
  名称：必须以持久层接口名称命名文件名，扩展名是.xml 
 2.在maven工程的resources目录下创建org/westos/dao 这个三级目录，然后在这个目录下
   创建IUserDao.xml 映射文件
   
 3.在  resources目录下创建org/westos/dao 这个三级目录时，你可以一级一级创建，不要直接写org.westos.dao, 这样创建出来是一个文件夹，你可以用 / 斜杠 隔开创建多级目录 例如：org/westos/dao 这样创建才是多级目录

IUserDao.xml 映射文件中的内容如下：需要注意namespace的值是接口的全限定名 id的值是接口中的方法名

<?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值是接口的全路径-->
<mapper namespace="org.westos.dao.IUserDao">
    <!--注意id的值是接口中的方法名 resultType 查询返回的结果类型-->
    <select id="findAll" resultType="org.westos.domain.User">
        select * from user;
    </select>
</mapper>

4.编写MyBatis的核心配置文件 SqlMapConfig.xml

1.在工程的resources目录下创建 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>
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <!--配置数据源的四个基本参数-->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    
    <!--引入dao接口的映射文件-->
    <mappers>
        <mapper resource="org/westos/dao/IUserDao.xml"></mapper>
    </mappers>
</configuration>

5.数据库和表的准备

我已经提前准备好了，可以从我的资料中导入

6.编写测试类，进行测试

1.在工程的Test 目录下的java目录下编写测试类进行测试

    public class TestUserDao {
    @Test
    public void testFindAll() throws IOException {
        //读取MyBatis的核心配置文件
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //构建工工厂
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        //打开SqlSession
        SqlSession sqlSession = factory.openSession();
        //获取接口的代理对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        //执行查询操作
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
        //释放资源
        in.close();
        sqlSession.close();
    }
}

7.入门案例总结

通过快速入门示例，我们发现使用 mybatis 是非常容易的一件事情，因为只需要编写 Dao 接口并且按照
mybatis 要求编写两个配置文件，就可以实现功能。远比我们之前的 jdbc 方便多了。（我们使用注解之后，将变得更为简单，只需要编写一个 mybatis 配置文件就够了。）

需要你注意的事项如下：
环境搭建的注意事项：
        第一个：创建IUserDao.xml 和 IUserDao.java时名称是为了和我们之前的知识保持一致。
            在Mybatis中它把持久层的操作接口名称和映射文件也叫做：Mapper
            所以：IUserDao 和 IUserMapper是一样的
        
        第二个：mybatis的映射配置文件位置必须和dao接口的包结构相同
        第三个：映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名
        第四个：映射配置文件的操作配置（select），id属性的取值必须是dao接口的方法名

        当我们遵从了第二，三，四，点之后，我们在开发中就无须再写dao的实现类。

8.入门案例流程图

保存用户的操作

1.在接口中添加一个保存的方法

public interface IUserDao {
    //查询所有用户
    List<User> findAll();
    //保存用户
    void saveUser(User user);
}

2.修改接口的映射文件

<!--注意namespace值是接口的全路径-->
<mapper namespace="org.westos.dao.IUserDao">
    <!--注意id的值是接口中的方法名 resultType 查询返回的结果类型-->
    <select id="findAll" resultType="org.westos.domain.User">
        select * from user;
    </select>
    <!--保存用户的操作 parameterType参数类型是User对象
        注意语法  #{username} 会通过反射调用getUsername()取出username的值
    -->
    <insert id="saveUser" parameterType="org.westos.domain.User">
        insert into user(username, birthday, sex, address) values (#{username},#{birthday},#{sex},#{address})
    </insert>
</mapper>

3.测试保存用户的操作，注意增删改的操作需要提交事务 sqlSession.commit()

 @Test
    public void testSaveUser() throws IOException {
        InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        SqlSession sqlSession = factory.openSession();
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        //创建一个对象
        User user = new User();
        user.setUsername("王力宏");
        user.setSex("男");
        user.setAddress("陕西西安");
        user.setBirthday(new Date());
        //保存用户
        dao.saveUser(user);
        //注意：增删改，要使用事务
        sqlSession.commit();//提交事务
        in.close();
        sqlSession.close();
    }

4.使用单元测试的注解

1.每次测试都得加载配置文件，获取SqlSession 麻烦，我们可以使用Junit单元测试的几个注解来解决，不用每次测试都得重复写 加载配置文件，获取SqlSession 的代码
2. @Before 注解在@Test注解执行之前调用 
   @After 注解在@Test执行完之后调用
3. 改造如下：
  public class TestUserDao {

    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private InputStream in;

    @Before //在@Test注解执行之前调用
    public void init() throws IOException {
        //读取MyBatis的核心配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //构建工厂
        factory = new SqlSessionFactoryBuilder().build(in);
        //打开SqlSession
        sqlSession = factory.openSession();
    }

    @Test
    public void testFindAll() throws IOException {

        //获取接口的代理对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        //执行查询操作
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
        //释放资源
        in.close();
        sqlSession.close();

    }

    @After //在@Test执行完之后调用
    public void destory() throws IOException {
        //释放资源
        in.close();
        sqlSession.close();
    }

使用dao接口实现类的方式，来进行查询所有用户的操作（了解）

1.我们刚才使用的方式，是只提供接口，并没有提供接口的实现类，但是MyBatis 是可以通过实现类，来完成增删改查的操作
2. 我们提供一个接口的实现类：如下

public class IUserDaoImpl implements IUserDao {

    private SqlSessionFactory sqlSessionFactory;
    //SqlSessionFactory对象通过构造方法，传递进来
    public IUserDaoImpl(SqlSessionFactory sqlSessionFactory) {
        this.sqlSessionFactory = sqlSessionFactory;
    }

    public List<User> findAll() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过映射文件中配置的 namespace="org.westos.dao.IUserDao" 和 id="findAll" 组合到一块，来确定这个方法的唯一性
        List<User> list= sqlSession.selectList("org.westos.dao.IUserDao.findAll");
        for (User user : list) {
            System.out.println(user);
        }
        return list;
    }
}

3.测试：
    @Test
    public void testFindAll2() throws IOException {
        //创建接口实现类的对象,把SqlSessionFactory对象传递过去
        IUserDaoImpl iUserDao = new IUserDaoImpl(factory);
        List<User> list = iUserDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
    }
  
4.说明：这种提供接口实现类的方式，麻烦，一般我们不采用。我们经常采用接口的代理对象的方式来做。

采用注解的方式实现查询所有用户的操作（先感受一下，后面再具体讲解注解的方式）

1.我们可以采用注解的方式来进行查询用户的操作，如果使用注解的方式，我们就不需要接口的映射文件，所有我们先把映射文件删掉
2.因为我们删掉了接口的映射文件，所以我们在SqlMapConfig.xml中引入映射文件的配置得修改一下
      <!--引入dao接口的映射文件-->
    <mappers>
       <!--
       注解的方式，不需要映射文件了
       <mapper resource="org/westos/dao/IUserDao.xml"></mapper>
       -->
        <!--我们通过class属性来引入接口的全路径-->
        <mapper class="org.westos.dao.IUserDao"></mapper>
    </mappers>
    
    
3.在接口的查询所有方法上加上一个@select注解
  public interface IUserDao {
    //查询所有用户
    @Select("select * from user")  //使用注解的方式来查询所有
    List<User> findAll();
}

4. 测试：
    @Test
    public void testFindAll() throws IOException {

        //获取接口的代理对象
        IUserDao userDao = sqlSession.getMapper(IUserDao.class);
        //执行查询操作
        List<User> list = userDao.findAll();
        for (User user : list) {
            System.out.println(user);
        }
        //释放资源
        in.close();
        sqlSession.close();

    }

更新用户和删除用户的操作

1.恢复到我们之前采用映射文件的方式

2.更新用户的操作

1.在接口中提供更新用户的方法
  public interface IUserDao {

    //查询所有用户
    List<User> findAll();
    //保存用户
    void saveUser(User user);
    //更新用户
    void updateUser(User user);
   } 
2.在映射文件中添加更新用户的配置
     <!--更新用户-->
  <update id="updateUser" parameterType="org.westos.domain.User">
      update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id};
  </update>
  
  
 3.测试
 
  @Test
    public void testUpdateUser() throws IOException {
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        //创建一个对象
        User user = new User();
        user.setId(64); //设置你要更改的用户的id
        user.setUsername("张学友");
        user.setSex("男");
        user.setAddress("陕西西安");
        user.setBirthday(new Date());
        //更新用户
        dao.updateUser(user);
        //注意：增删改，要使用事务
        sqlSession.commit();//提交事务
    }

3.删除一个用户

1.在接口中提供删除用户的方法
    public interface IUserDao {

    //查询所有用户
    List<User> findAll();
    //保存用户
    void saveUser(User user);
    //更新用户
    void updateUser(User user);
    //根据id删除用户
    void deleteUser(Integer id);
    
   } 
   
2.在映射文件中添加删除用的配置
     <!--删除用户 
    parameterType 参数类型可以写 int INT 或者 java.lang.Integer 都可以。
    因为MyBatis框架针对int类型提供了别名所以写 int INT 都行。
    -->
    <delete id="deleteUser" parameterType="java.lang.Integer">
        <!--#{uid} 这里传入参数只有一个，所以这个名字可以随意写，只是一个占位符的作用-->
        delete from user where id=#{uid} 
    </delete>
 3. 测试：
    @Test
    public void testDeleteUser() throws IOException {
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        //删除用户
        dao.deleteUser(64);
        //注意：增删改，要使用事务
        sqlSession.commit();//提交事务
    }

查询单个用户和模糊查询

1.根据id查询单个用户

1.在接口中添加查询单个用户的方法

 public interface IUserDao {

    //查询所有用户
    List<User> findAll();
    //保存用户
    void saveUser(User user);
    //更新用户
    void updateUser(User user);
    //根据id删除用户
    void deleteUser(Integer id);
    //根据id查询一个用户
    User selectUserById(Integer id);
 }   
 
 2.在映射文件中添加配置
 <!--查询单个用户-->
    <select id="selectUserById" resultType="org.westos.domain.User" parameterType="INT">
        select * from user where id=#{uid};
    </select>
    
3.测试
   @Test
    public void testSelectUserByID(){
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        User user = dao.selectUserById(63);
        System.out.println(user);
    }

2.根据姓名模糊查询

1.在接口中添加模糊查询的方法
public interface IUserDao {
    //根据姓名模糊查询
    List<User> likeUserByUsername(String username);
}  

2. 在映射文件中添加配置
  <!--根据姓名模糊查询-->
    <select id="likeUserByUsername" resultType="org.westos.domain.User" parameterType="string">
        select * from user where username like #{uname};
    </select>
    
 3.测试
 
  @Test
    public void testLikeSelect() {
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        List<User> list = dao.likeUserByUsername("%沈%");
        for (User user : list) {
            System.out.println(user);
        }

    }

聚合函数的查询

1.查询所有用户的个数

1.在接口中提供查询所有用户个数的方法
public interface IUserDao {
    //查询所有用户的个数
    int selectAllUserCount();
}

2.在映射文件中添加配置
 <select id="selectAllUserCount" resultType="int">
        select count(*) from user;
 </select>
 
3.测试
  @Test
    public void testCount(){
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        int sum = dao.selectAllUserCount();
        System.out.println(sum);
    }

获取自增长键的值

1.但我新保存一个用户时，我想获取刚插入的这条数据的自增长键的值

1.要获取自增长键的值，其实就是利用MySQL的一个函数
   SELECT LAST_INSERT_ID();
   
2. 在映射文件中保存用户的操作中添加配置  
       <insert id="saveUser" parameterType="org.westos.domain.User">
        <!--获取自增长键的值的配置-->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            SELECT LAST_INSERT_ID();
        </selectKey>
        insert into user(username, birthday, sex, address)
        values (#{username}, #{birthday}, #{sex}, #{address});
    </insert>
    说明：keyProperty="id" 实体类中的id表示自增长键
          keyColumn="id" 表中的主键名
          resultType="int" 返回类型
           order="AFTER"  在插入之后获取自增长键的值
           
 3.测试：在保存完用户后，获取 id的值
     @Test
    public void testSaveUser() throws IOException {
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        //创建一个对象
        User user = new User();
        user.setUsername("王力宏");
        user.setSex("男");
        user.setAddress("陕西西安");
        user.setBirthday(new Date());
        //保存用户
        dao.saveUser(user);
        //注意：增删改，要使用事务
        sqlSession.commit();//提交事务
        //在保存之后，获取id的值
        Integer id = user.getId();
        System.out.println(id);
    }

parameterType传入参数的类型

我们在上一章节中已经介绍了 SQL 语句传参，使用标签的 parameterType 属性来设定。
该属性的取值可以 是基本类型，引用类型（例如:String 类型）
，还可以是实体类类型（POJO 类）。
同时也可以使用实体类的包装 类，本章节将介绍如何使用实体类的包装类作为参数传递。 

 开发中通过 pojo 传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查 询条件（比如将用户购买商品信息也作为查询条件），
这时可以使用包装对象传递输入参数。 Pojo 类中包含 pojo。 
需求：根据用户名查询用户信息，查询条件放到 QueryVo 的 user 属性中。

1.创建一个QueryVo类，类中维护着一个User对象

public class QueryVO {
    User user;
    //get set 方法略 自己补上
}

2.在接口中提供查询方法，方法的参数要一个 QueryVO类型

public interface IUserDao {
    //根据VO模糊查询
    List<User> likeUserByVO(QueryVO vo);
}

3.在映射文件中添加配置

 <!--根据vo模糊查询-->
    <select id="likeUserByVO" resultType="org.westos.domain.User" parameterType="org.westos.domain.QueryVO">
        select * from user where username like #{user.username}
    </select>
    
说明：#{user.username}   user是QueryVO中的属性 会通过反射调用 getUser()获取User的对象
     username 是User中的属性，会通过getUsername来获取值

4.测试

@Test
    public void testLikeByVO() {
        IUserDao dao = sqlSession.getMapper(IUserDao.class);
        User user = new User();
        user.setUsername("%沈%");
        QueryVO queryVO = new QueryVO();
        //把User对象设置给VO
        queryVO.setUser(user);
        List<User> list = dao.likeUserByVO(queryVO);
        for (User user1 : list) {
            System.out.println(user1);
        }

    }

实体类的属性名和表中的字段名不一致怎么办

1.我们在开始做入门案例的时候，我们让User中的属性名和user表中的字段名是保持一致的。
  那么我们不保持一致，可以处理吗?可以， 但是需要我们再增加配置，配置实体类属性和表中字段的对应关系即可

1.把实体类中的属性名改一下

public class User implements Serializable {
 
    private Integer user_id;
    private String user_username;
    private Date user_birthday;
    private String user_sex;
    private String user_address;
     //get set 方法略 自己补上
 }

2.在映射文件中配置实体类的属性名和表中字段名的对应关系

 <resultMap id="myMap" type="org.westos.domain.User">
        <!--配置实体类和表中主键的对应关系-->
        <id property="user_id" column="id"></id>
        <!--配置其他普通字段的对应关系-->
        <result property="user_username" column="username"></result>
        <result property="user_birthday" column="birthday"></result>
        <result property="user_sex" column="sex"></result>
        <result property="user_address" column="address"></result>
    </resultMap>

3.修改返回数据类型的配置

  <select id="findAll" resultMap="myMap">
    select *from user;
  </select>
  
说明：使用  resultMap="myMap" 来引用我们的映射配置

4.测试查询用户即可

使用properties标签引用外部的配置文件

1.回到我们的核心配置文件SqlMapConfig.xml 我们在里面配置了连接数据库的四个基本参数配置
<dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis_test"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
            
 2.那能不能把这些配置单独写在一个外部的配置文件中呢?可以。
 在resources目录下新键一个文件jdbcConfig.properties 文件中内容如下
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_test
jdbc.username=root
jdbc.password=123456

3.在SqlMapConfig.xml中使用<properties>标签引入外部的配置文件
    注意：resource 是引用类路径下的配置文件，这个标签放到<configuration>标签里面的最前面
   <properties resource="jdbcConfig.properties">

    </properties>
    
4.修改<dataSource> 标签中的配置
   注意：value的值要和外部配置文件中的键名保持一致
 <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>

给实体类起别名

1.我们回到SqlMapConfig.xml中使用  <typeAliases>标签给实体类起个别名
 <!--给实体类配置别名-->
    <typeAliases>
        <typeAlias type="org.westos.domain.User" alias="user"></typeAlias>
  </typeAliases>
 这个别名在使用时可以写user 或者Use 或者USER 都行
 
 2.在配置了别名后，我们在映射文件中返回参数类型和传入参数类型就可以使用别名了，不需要写User的全路径名
 <update id="updateUser" parameterType="user"> 
      update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id};
  </update>
 
 3.如果说，我们有很多个实体类，那么一个一个去配置别名麻烦
 我们可以使用 package 来给该包下所有的实体类配置别名
 
 <typeAliases>
        <!--<typeAlias type="org.westos.domain.User" alias="user"></typeAlias>-->
         <!--这是该给包下所有的实体类配置了别名-->
        <package name="org.westos.domain"></package>
  </typeAliases>
  说明：给某个包下所有的实体类配置了别名，这个别名叫啥，可以是 原来的类名 可以是原来的类名全部小写，或全部大写  例如：User或 user 或 USER 这三个 都是别名 用哪个都行

使用package标签扫描该包下所有接口

如果一个包下的接口太多一个一个去扫描麻烦，那么可以使用 <package>标签 扫描该包下所有的接口
<mappers>
      <!-- <mapper resource="org/westos/dao/IUserDao.xml"></mapper>-->
        <!--扫描该包下所有的dao接口-->
        <package name="org.westos.dao"></package>
    </mappers>