11.MyBatis_全局配置文件和CRUD

1.properties标签

• 用来引入外部的属性文件连接数据库

<!-- 1.通过properties标签引入外部的属性文件

         resource属性：引入类路径下的文件

          url 属性：引入一个网络上或者磁盘上的文件

     -->

     <!--

        获取连接 数据库有关信息的步骤：

             1） 获取properties标签中设置的值

             2）如果外部属性文件中也有对应的值，将覆盖1）中的值

             3）如果从1）和2）中都没有得到，将使用dataSource标签的子标签property中设置的值

      -->

     < properties resource = "db.properties" >

          < property name = "jdbc.username" value = "admin" />

          < property name = "jdbc.password" value = "123456" />

     </ properties >

2.settings标签

• 通过该标签的子标签settiong对一些属性进行设置

<!-- 2.通过settings标签对MyBatis中的某些属性进行配置 -->

     < settings >

          <!-- settion 子标签：

             name：要设置的属性的属性名

             value：要设置的属性值

             mapUnderscoreToCamelCase：设置是否开启驼峰命名法，默认是false，不开启，

                 当设置为true时， 数据中的下划线将自动映射为驼峰命名

         

是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN 到经典 Java 属性名 aColumn 的类似映射。

 -->

          < setting name = "mapUnderscoreToCamelCase" value = "true" />

     </ settings >

3.typeAliases标签

• 通过该标签的子标签typeAliase或者package给某些类起别名

<!-- 3.通过typeAliases标签给某些类起别名（ 不建议使用 ） -->

     < typeAliases >

          <!--

             子标签typeAlias：给某一个类起别名

                 type属性：设置要起别名的类的全类名，默认的别名是类的首字母小写，但是别名不区分大小写

                 alias属性：设置别名

             子标签package：给某一个包下的类起别名

                 -我们也可以通过@Alias注解给某个类起别名

          -->

<!--         <typeAlias type="com.atguigu.mybatis.entities.Employee" alias=" emp "/> -->

          < package name = "com.atguigu.mybatis.entities" />

     </ typeAliases >

？4.typeHandlers标签

• 通过该标签的子标签typeHandler在MyBatis的全局配置文件中注册类型转换器

<!-- 4.通过typeHandlers注册类型转换器 -->

     <!--

         对于日期和时间的处理：MyBatis3.4以前的版本需要我们手动注册这些处理器，以后的版本都是自动注册的

     -->

     < typeHandlers >

          < typeHandler handler = "自定义的类型转换器的全类名" />

     </ typeHandlers >

？5.plugins标签

• 通过该标签的子标签plugin注解插件对MyBatis的四大对象进行拦截（后面会使用一个PageHelper的插件）

<!-- 5.通过 plugins 注册插件可以对MyBatis的四大对象

          Executor、ParameterHandler、ResultSetHandler、StatementHandler进行拦截-->

     < plugins >

          < plugin interceptor = "插件的全类名" ></ plugin >

     </ plugins >

6.environments标签

• 用来配置多个环境
• 通过该标签的子标签environment配置一个个的环境（如开发环境、测试环境、生产环境）

<!-- 6.通过environments标签配置环境们 -->

     <!-- default属性：用来 设置使用那一个环境 ， 该属性值为环境的id属性值 -->

     < environments default = "development" >

          <!-- id属性：给当前环境设置一个唯一的标识 -->

          < environment id = "development" >

              <!--

                  子标签transactionManager：用来设置事务管理器

                          type属性可选值：

                               -JDBC：对应的实现JdbcTransactionFactory

                               -MANAGED：对应的实现ManagedTransactionFactory

                               -自定义：只需要实现TransactionFactory

                           不过最终事务管理器要交给Spring来配置  

              -->

              < transactionManager type = "JDBC" />

              <!--

                  子标签dataSource：用来配置数据源

                      type属性的可选值：

                          -UNPOOLED：对应的实现UnpooledDataSourceFactory

                          -POOLED：对应的实现PooledDataSourceFactory

                          -JNDI：对应的实现JndiDataSourceFactory

                          -自定义：只需要实现DataSourceFactory

                      不过最终数据源也是在Spring中进行配置       

              -->

              < dataSource type = "POOLED" >

                  < property name = "driver" value = "${jdbc.driverClass}" />

                  < property name = "url" value = "${jdbc.jdbcUrl}" />

                  < property name = "username" value = "${jdbc.username}" />

                  < property name = "password" value = "${jdbc.password}" />

              </ dataSource >

          </ environment >

<!--         <environment id="test"></environment> -->

     </ environments >

7.databaseIdProvider标签

• 通过该标签来设置执行不同的sql语句及设置各个数据库厂商的别名

<!-- 7.通过databaseIdProvider标签来执行不同的 sql 语句 -->

     <!--

         type属性的值为：

             -DB_VENDOR

                 -MyBatis会通过VendorDatabaseIdProvider实现类解析不同的数据库厂商的标识

             -自定义：只需要实现DatabaseIdProvider接口 

     -->

     < databaseIdProvider type = "DB_VENDOR" >

          <!--

             我们可以通过property标签为不同的数据库厂商起别名

                 name属性：数据库厂商的标识

                 value属性：为数据库厂商起的别名

          -->

          < property name = "SQL Server" value = "sqlserver" />

          < property name = "MySQL" value = "mysql" />

          < property name = "DB2" value = "db2" />

          < property name = "Oracle" value = "oracle" />

     </ databaseIdProvider >

• 如果要实现连接不同的数据库执行不同的sql语句，在写sql语句的标签中需要添加一个databaseId属性设置数据库厂商的别名

<!--

         id属性：用来设置接口中的方法的名字

         resultType属性：用来设置查询出来的数据要封装的对象的全类名

         databaseId属性：设置一个数据库厂商的标识，此时当连接对应的数据库时就会执行该 sql 语句

             -如果指定了该属性，那么没有指定该属性的 sql 语句将会被废弃

     -->

     < select id = "getEmployeeById" resultType = "com.atguigu.mybatis.entities.Employee" databaseId = "mysql" >

         select id,last_name,email,salary

         from employees where id = #{id}

     </ select >

     < select id = "getEmployeeById" resultType = "com.atguigu.mybatis.entities.Employee" databaseId = "oracle" >

         select id,last_name,email,salary,dept_id

         from employees where id = #{id}

     </ select >

     < select id = "getEmployeeById" resultType = "com.atguigu.mybatis.entities.Employee" >

         select id,last_name,email,salary,dept_id

         from employees where id = #{id}

     </ select >

8.mappers标签

• 用来注解Mapper接口的映射文件
• 可以通过该子标签mapper和package实现映射文件的注册

<!-- 8.通过 mappers 标签注册 Mapper 接口的映射文件 -->

     < mappers >

          <!-- 注册接口的映射文件 -->

          <!--

              子标签 mapper ：注册映射文件

                  resource 属性：注册类路径下的映射文件

                  url ：注册网络或者磁盘上的映射文件

                  class ：设置 Mapper 接口的全类名

                      -如果使用注解的方式可以执行成功（不建议使用注解的方式）

                      -如果不使用注解的方式， Mapper 接口的映射文件必须要与 Mapper 接口同名并且在同一个包下

              子标签package ：通过指定包名来注册映射文件

                      -如果使用注解的方式可以执行成功（不建议使用注解的方式）

                      -如果不使用注解的方式， Mapper 接口的映射文件必须要与 Mapper 接口同名并且在同一个包下 

          -->

          < mapper resource = "EmployeeMapper.xml" />

<!--             <mapper class="com.atguigu.mybatis.mapper.EmployeeMapper"/> -->

<!--             <package name="com.atguigu.mybatis.mapper"/> -->

     </ mappers >

9. 通过MyBatis实现普通的增删改查的操作

• Mapper接口

public interface EmployeeMapper {

     /**

     * 根据员工的id获取Employee对象

     *

     * @param id

     * @return

     */

     // @Select("select id,last_name,email,salary,dept_id from employees where id

     // = #{id}")

     public Employee getEmployeeById(Integer id );

     /**

     * 获取所有的Employee对象

     *

     * @return

     */

     public List<Employee> getEmployees();

     /**

     * 向数据库中插入Employee

     *

     * @param employee

     */

     public void insertEmployee(Employee employee );

     /**

     * 更新Employee

     *

     * @param employee

     */

     public boolean updateEmployee(Employee employee );

     /**

     * 删除Employee

     *

     * @param id

     * @return

     */

     public int deleteEmployeeById(Integer id );

}

• 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" ; >

<!-- namespace 属性： 用来设置接口的全类名 -->

< mapper namespace = "com.atguigu.mybatis.mapper.EmployeeMapper" >

     <!--

          id属性 ：用来设置 接口中的方法的名字

          resultType属性 ：用来设置 查询出来的数据要封装的对象的全类名

          databaseId属性：设置一个数据库厂商的标识，此时当连接对应的数据库时就会执行该 sql 语句

             -如果指定了该属性，那么没有指定该属性的 sql 语句将会被废弃

     -->

     < select id = "getEmployeeById" resultType = "com.atguigu.mybatis.entities.Employee" >

         select id,last_name,email,salary,dept_id

         from employees where id = #{id}

     </ select >

     <!-- 如果返回时List，那么resultType指定的是List中的 泛型的类型 -->

     < select id = "getEmployees" resultType = "com.atguigu.mybatis.entities.Employee" >

         select id,last_name,email,salary,dept_id

         from employees

     </ select >

    

     <!-- parameterType：指定方法传入的参数的类型，该可以省略 -->

     < insert id = "insertEmployee" parameterType = "com.atguigu.mybatis.entities.Employee" >

         insert into employees(last_name,email,salary,dept_id)

        values(#{lastName},#{email},#{salary},#{deptId})

     </ insert >

    

     < update id = "updateEmployee" >

         update employees set last_name=#{lastName},email=#{email},salary=#{salary},dept_id=#{deptId}

         where id=#{id}

     </ update >

    

     < delete id = "deleteEmployeeById" >

         delete from employees where id = #{a}

     </ delete >

</ mapper >

• 测试

// 或SqlSessionFactory的方法

     public SqlSessionFactory getSqlSessionFactory() throws IOException {

         String resource = "mybatis-config.xml" ;

         InputStream inputStream = Resources. getResourceAsStream ( resource );

         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build( inputStream );

          return sqlSessionFactory ;

    }

     /**

     * 面向 Mapper 接口开发的好处： JDBC：EmployeeMapper→EmployeeMapperImpl

     * MyBatis：EmployeeMapper→配置EmployeeMapper.xml文件→MyBatis会创建代理实现类

     * 1.接口中明确了传入的参数的类型 2.接口中方法有明确的返回值

     * 3.接口是抽象的，抽象出了规范，可以通过不同的技术来实现它：可以通过JDBC、 Hibernate 、MyBatis等来实现

     *

     * @throws IOException

     */

     //获取一个员工

     @Test

     public void testGetEmployeeById() throws IOException {

          // 1.获取SqlSessionFactory对象

         SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

          // 2.获取sqlSession对象，就相当于JDBC中的Connection

         SqlSession session = sqlSessionFactory .openSession();

          try {

              // 3. 获取 Mapper 对象

             EmployeeMapper employeeMapper = session .getMapper(EmployeeMapper. class );

              // 调用EmployeeMapper中的方法获取Employee对象

             Employee employee = employeeMapper .getEmployeeById(1);

              // Object employee = session.selectOne("getEmployee", " abc ");

             System. out .println( employee );

         } finally {

              session .close();

         }

    }

     //获取所有的员工

     @Test

     public void testGetEmployees() throws IOException {

          // 1.获取SqlSessionFactory

         SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

          // 2.获取sqlSession

         SqlSession session = sqlSessionFactory .openSession();

          try {

              // 3. 获取 Mapper 对象

             EmployeeMapper employeeMapper = session .getMapper(EmployeeMapper. class );

              // 4.调用EmployeeMapper中的方法获取所有的Employee对象

             List<Employee> employees = employeeMapper .getEmployees();

              for (Employee employee : employees ) {

                 System. out .println( employee );

             }

         } finally {

              session .close();

         }

    }

     // 添加员工

     @Test

     public void testInsertEmployee() throws IOException {

          // 1.获取SqlSessionFactory

         SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

          // 2.获取sqlSession

         SqlSession session = sqlSessionFactory .openSession();

          try {

              // 3.获取 Mapper 对象

             EmployeeMapper employeeMapper = session .getMapper(EmployeeMapper. class );

              // 4.调用EmployeeMapper中的方法添加Employee对象

             Employee employee = new Employee( null , "许刚" , " xg@ggx.com " , 250.00, 6);

              employeeMapper . insertEmployee( employee ) ;

              //手动提交

              session .commit();

         } finally {

              session .close();

         }

    }

     //更新员工

     @Test

     public void testUpdateEmployee() throws IOException {

          // 1.获取SqlSessionFactory

         SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

          // 2.获取sqlSession

         SqlSession session = sqlSessionFactory .openSession();

          try {

              // 3.获取 Mapper 对象

             EmployeeMapper employeeMapper = session .getMapper(EmployeeMapper. class );

              // 4.调用EmployeeMapper中的方法更新Employee对象

             Employee employee = new Employee(13, "许小刚" , " xxg@ggx.com " , 10.00, 7);

              boolean updateEmployee = employeeMapper .updateEmployee( employee );

             System. out .println( updateEmployee );

              //手动提交

              session .commit();

         } finally {

              session .close();

         }

    }

     //删除员工

     @Test

     public void testDeleteEmployeeById () throws IOException {

          // 1.获取SqlSessionFactory

         SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

          // 2.获取sqlSession

         SqlSession session = sqlSessionFactory .openSession();

          try {

              // 3.获取 Mapper 对象

             EmployeeMapper employeeMapper = session .getMapper(EmployeeMapper. class );

              // 4.调用EmployeeMapper中的方法删除Employee对象

              int deleteEmployeeById = employeeMapper .deleteEmployeeById(11);

             System. out .println( deleteEmployeeById );

              //手动提交

              session .commit();

         } finally {

              session .close();

         }

    }