<?xml version="1.0" encoding="UTF-8" ?>

<!-- dtd约束 -->

<!DOCTYPE configuration

  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

  "http://mybatis.org/dtd/mybatis-3-config.dtd">

<!-- 根元素: 用于配置mybatis -->

<configuration>

  <!-- 配置mybatis的运行环境 ,可以配置多个环境,但是一次只能使用一个

     default属性 : 当前使用的环境 ,使用下面环境的id 即可  -->

  <environments default="dev_mysql">

     <!-- 环境配置  id 属性,就是当前环境的表示 -->

    <environment id="dev_mysql">

      <!-- 配置MyBatis事务管理器

         type属性 :  事物类型

             JDBC  使用事务(正常提交commit,异常回滚事务 rollback) 默认

             MANAGED : 不使用事务

        -->

      <transactionManager type="JDBC"/>

      <!-- 配置MyBatis的数据源

         type : 配置连接池

             POOLED :mybatis内置的一个连接池(默认)

             后期都交给spring管理了,配置 dbcp连接池,阿里巴巴的 druid连接池

       -->

      <dataSource type="POOLED">

         <!-- 连接数据库的操作 -->

         <!-- 数据库驱动 -->

        <property name="driver" value="com.mysql.jdbc.Driver"/>

        <!-- 连接数据库的url -->

        <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>

        <!-- 连接数据库账号 -->

        <property name="username" value="root"/>

        <!-- 连接数据库密码 -->

        <property name="password" value="admin"/>

      </dataSource>

    </environment>

  </environments>

  <!-- 配置映射文件 -->

  <mappers>

     <!-- 配置包扫描映射文件 -->

     <!-- <package name=""/> -->

     <!-- 配置单个映射文件 -->

    <mapper resource="org/mybatis/example/BlogMapper.xml"/>

  </mappers>

</configuration>

package cn.zj.mybatis.util;

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;

public class MyBatisUtil {

    private MyBatisUtil() {

    }

    //SqlSessionFactory 会话工厂对象

    private static SqlSessionFactory  factory;

    //类加载到JVM中就立马执行static代码块,并且只会执行一次

    static {

        //资源文件

        String resource = "mybatis-config.xml";

        //try(){}catch(Exception e){} try的圆括号内部能够自动释放/关闭资源

        try(InputStream inputStream = Resources.getResourceAsStream(resource)) {

            //创建SqlSessionFactory 对象

            factory = new SqlSessionFactoryBuilder().build(inputStream);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**

     * 创建SqlSession对象

     * @return SqlSession对

     */

    public static SqlSession openSession() {

        //创建Session对象

        SqlSession session = factory.openSession();

        return session;

    }

}

package cn.zj.mybatis.pojo;

public class User {

    private Integer id;

    private String name;

    private String password;

    private Integer age;

    public User() {

        super();

    }

    public User(Integer id, String name, String password, Integer age) {

        super();

        this.id = id;

        this.name = name;

        this.password = password;

        this.age = age;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    @Override

    public String toString() {

        return "User [id=" + id + ", name=" + name + ", password=" + password + ", age=" + age + "]";

    }

}

package cn.zj.mybatis.mapper;

import cn.zj.mybatis.pojo.User;

/*

 * 使用MyBatis的动态代理开发编写代码遵循四个原则

 *  1.映射文件的namespace命名空间的值必须是对应接口的全限定名

    2.映射文件的对应功能 id值必须等于映射接口中方法的名称

    3.映射文件的参数类型必须和接口中方法的参数类型一致

    4.映射文件查询的返回结果类型必须和接口的方法的返回数据类型一致，

        DML操作返回的受影响的行数，除外

 */

public interface UserMapper {

    int insertUserInfo(User u);

}

<?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="cn.zj.mybatis.pojo.UserMapper">

    <!-- 新增操作

        id: 当前功能的唯一标识,和接口方法同名

        parameterType ： 参数的类型

        useGeneratedKeys：是否返回数据库生成的主键 true是/false否

        keyProperty : 数据库主键对应java的pojo对象的属性

        keyColumn : 数据表的主键列明

     -->

    <insert id="insertUserInfo" parameterType="User"

        useGeneratedKeys="true"

        keyProperty="id"

        keyColumn="id"

    ></mapper>

    //插入操作

// 新增操作

@Test

public void testInsert() throws Exception {

    //1.创建SqlSession操作对象

    SqlSession session = MyBatisUtil.openSession();

    //2.创建UserMapper接口的代理对象

    UserMapper userMapper = session.getMapper(UserMapper.class);

    //3.创建用户对象

    User user = new User(null, "乔峰", "qf", 30);

    //4.执行UserMapper的插入操作

    userMapper.insertUserInfo(user);

    //5.提交事务

    session.commit();

    //6.关闭session

    session.close();

}

# Global logging configuration

log4j.rootLogger=ERROR, stdout

# MyBatis logging configuration...

# log4j.logger.org.mybatis.example.BlogMapper=TRACE

#  前缀(log4j.logger)+点（.）需要记录日志的命名空间 = 日志级别

log4j.logger.cn.zj.mybatis.mapper=TRACE

# 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

 <!-- 单行查询

  resultType : 查询结果对应的封装的返回类型

   -->

  <select id="selectByUserId" parameterType="integer" resultType="cn.zj.mybatis.pojo.User">

     select * from user where id = #{id}

  </select>

// 单行查询

@Test

public void testFindById() throws Exception {

    //1.创建SqlSession操作对象

    SqlSession session = MyBatisUtil.openSession();

    //2.创建UserMapper接口的代理对象

    UserMapper userMapper = session.getMapper(UserMapper.class);

    //3.执行单行查询操作

    User user = userMapper.selectByPrimaryKey(1);

    System.out.println(user);

    // 4.关闭session

    session.close();

}

<!-- 多行查询

     resultType : 无论是多行查询还是单行查询,返回的结果类型都是对应的JavaBean的类型

   -->

  <select id="selectAll" resultType="cn.zj.mybatis.pojo.User">

     select * from user

  </select>

@Test

public void testFindAll() throws Exception {

    SqlSession session = MyBatisUtil.openSession();

    // 创建UserMaper的代理对象

    UserMapper mapper = session.getMapper(UserMapper.class);

    // 3.执行多行查询

    List<User> users = mapper.selectAll();

    for (User user : users) {

        System.out.println(user);

    }

    // 4.关闭session

    session.close();

}

<!-- 删除操作  -->

  <delete id="deleteById" parameterType="integer">

     delete from user where id = #{id}

  </delete>

// 删除操作

@Test

public void testDelete() throws Exception {

    // 1.创建SqlSession操作对象

    SqlSession session = MyBatisUtil.openSession();

    // 2.创建UserMapper接口的代理对象

    UserMapper userMapper = session.getMapper(UserMapper.class);

    // 3.执行UserMapper的插入操作

    userMapper.deleteById(3);

    // 4.提交事务

    session.commit();

    // 5.关闭session

    session.close();

}

<!-- 修改操作 -->

  <update id="updateByUserId" parameterType="cn.zj.mybatis.pojo.User">

     update user set name = #{name},password = #{password},age = #{age} where id = #{id}

  </update>

// 修改操作

@Test

public void testUpdate() throws Exception {

    // 1.创建SqlSession操作对象

    SqlSession session = MyBatisUtil.openSession();

    // 2.创建UserMapper接口的代理对象

    UserMapper userMapper = session.getMapper(UserMapper.class);

    // 3.创建用户对象

    User user = new User(2, "段誉", "dy", 25);

    // 4.执行UserMapper的插入操作

    userMapper.updateUserInfo(user);

    // 5.提交事务

    session.commit();

    // 6.关闭session

    session.close();

}

<?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="cn.zj.mybatis.mapper.UserMapper">

    <!--

        resultType : 自动映射

        resultMap ： 手动映射，值 自定义对应手动映射标签的 id的值

        注意：自动映射和手动映射二选一，不能同时使用

     -->

    <select id="findByUserId" parameterType="Integer"  resultMap="user_map">

        <!-- #{} OGNL表达式语言  -->

        select id  u_id,name u_name,password u_password ,age u_age from user  where id = #{id}

    </select>

    <!-- 手动映射

        type :需要手动映射的数据类型

        id ：唯一标识

     -->

    <resultMap type="User" id="user_map">

        <!--

            主键列映射

            <id column="" property="" javaType="" jdbcType=""/>

            column :结果的列名

            property:domain对象的对应的属性名

            javaType :domian对象的属性的类型（可选，默认自动关联）

            jdbcType :结果集列类型（可选，默认自动关联）

         -->

        <id column="u_id" property="id" javaType="Integer" jdbcType="INTEGER"/>

        <!--

            主键列映射

            <result column="" property="" javaType="" jdbcType=""/>

            column :结果的列名

            property:domain对象的对应的属性名

            javaType :domian对象的属性的类型（可选，默认自动关联）

            jdbcType :结果集列类型（可选，默认自动关联）

        -->

        <result column="u_name" property="name"/>

        <result column="u_age" property="age"/>

        <result column="u_password" property="password"/>

    </resultMap>

    <!-- 多行查询

        注意：查询不管单行还是多行查询，返回的数据类型都是数据表对应的domain类型

        多行不是放回集合

    -->

    <select id="selectAll" resultMap="user_map">

        select id  u_id,name u_name,password u_password ,age u_age from user

    </select>

</mapper>

<!ELEMENT configuration (properties?, settings?, typeAliases?, typeHandlers?, objectFactory?, objectWrapperFactory?, reflectorFactory?, plugins?, environments?, databaseIdProvider?, mappers?)>

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "mybatis-3-config.dtd" >

<!-- XMLConfigBuilder是总配置文件的构建类 -->

<configuration>

<!-- 别名设置  -->

    <typeAliases>

        <!-- 设置单个类的别名

            type ：要设置别名的全限定名

            alias ：别名

        -->

        <typeAlias type="cn.zj.mybatis.pojo.User" alias="User"/>

    </typeAliases>

  <!-- 用于配置数据库的连接参数 ,environments这个标签可以配置多个数据库的连接,default表示默认使用的配置-->

  <environments default="default-msql">

     <!-- 数据库的连接参数 Configuration查看参数-->

     <!-- 所有框架的静态属性都可以在这个框架的类里面找到,不用死记硬背 -->

     <!-- id:就是一个标识符 -->

     <environment id="default-msql">

        <!-- 事务类型 -->

        <!-- 事务类型有哪些

         JDBC:使用JDBC事务

         MANAGED:不用事务

         -->

        <transactionManager type="JDBC"></transactionManager>

        <!-- 数据源 -->

        <!-- type表示数据库的类型

           JNDI:使用JNDI获得数据源.

           POOLED:使用默认的连接池获得数据源

           UNPOOLED:不用数据源

          -->

          <!-- org.apache.ibatis.datasource.pooled.PooledDataSource -->

        <dataSource type="POOLED">

           <!-- 所有的property对应的是一个set方法 -->

           <!-- 四要素 -->

           <property name="driver" value="org.gjt.mm.mysql.Driver"/>

           <property name="url" value="jdbc:mysql://localhost:3306/school"/>

           <property name="username" value="root"/>

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

        </dataSource>

     </environment>

  </environments>

  <!-- 加载映射文件 -->

  <mappers>

    <mapper resource="mybatis-mapper/StudentMapper.xml"/>

  </mappers>

</configuration>

<?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="test">

    <!-- 单行查询操作

        <select id="">

            id :当前功能唯一标识

            parameterType ： 当前参数的数据类型

            resultType ：查询结果要封装返回对象的数据类型

            标签内部的文本内容： 要操作SQL语句

     -->

    <select id="findById" parameterType="Integer" resultType="User">

        <!-- #{} OGNL表达式语言  -->

        select * from user where id = #{id}

    </select>

    <!-- 多行查询

        注意：查询不管单行还是多行查询，返回的数据类型都是数据表对应的pojo类型

        多行不是放回集合

    -->

    <select id="findAll" resultType="User">

        select * from user

    </select>

    <!-- 新增数据

        keyProperty ： 数据库表主键对应的pojo类型的属性

        useGeneratedKeys: 是否生成主键，如果为true，数据保存以后

        MyBatis会自动把数据库当前数据的主键值设置pojo对应的id中去

     -->

    <insert id="insertUserInfo"

            parameterType="User"

            keyProperty="id"

            useGeneratedKeys="true">

            <!-- #{对象的属性名称} -->

        insert into user (name,password,age)values(#{name},#{password},#{age})     

    </insert>

    <!-- 删除数据 -->

    <delete id="deleteById" parameterType="Integer" >

        delete from user where id = #{id}

    </delete>

    <!--

        修改操作

     -->

     <update id="updateUserInfoById" parameterType="User">

        update user set name = #{name} ,password = #{password},age = #{age} where id = #{id}

     </update>

</mapper>

别名

映射的类型

_byte

byte

_long

long

_short

short

_int

int

_integer

int

_double

double

_float

float

_boolean

boolean

string

java.lang.String

byte

Byte

long

Long

short

Short

int

Integer

integer

Integer

double

Double

float

Float

boolean

Boolean

date

java.util.Date

decimal

BigDecimal

bigdecimal

BigDecimal

object

Object

map

java.util.Map

hashmap

HashMap

list

List

arraylist

ArrayList

collection

Collection

iterator

Iterator

jdbc.driverClassName=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/mybatis

jdbc.username=root

jdbc.password=root

 <!-- 根标签，在内部配置MyBatis框架信息 -->

<configuration>

    <!-- 读取classpath下面的 数据库配置文件、

        读取以后再下面链接数据库的配置中就可以使用

        ${配置文件key} 获取对应的数据库连接相关信息

     -->

    <properties resource="db.properties"/>

      -->

    <environment id="mysql">

    <!-- 配置事务管理器

        type ： 事务管理器的类型，使用的MyBatis框架自定义的一种别名

           JDBC :使用原生的JDBC作为事务管理

     -->

      <transactionManager type="JDBC"/>

         <!-- 配置MyBatis的数据源

         type : 配置连接池

         POOLED :mybatis内置的一个连接池(默认)

             后期都交给spring管理了,配置 dbcp连接池,阿里巴巴的 druid连接池

       -->

      <dataSource type="POOLED">

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

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

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

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

      </dataSource>

    </environment>

设置参数

描述

有效值

默认值

cacheEnabled

该配置影响的所有映射器中配置的缓存的全局开关。

true | false

TRUE

lazyLoadingEnabled

延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。

true | false

FALSE

aggressiveLazyLoading

当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods).

true | false

false (true in ≤3.4.1)

multipleResultSetsEnabled

是否允许单一语句返回多结果集（需要兼容驱动）。

true | false

TRUE

useColumnLabel

使用列标签代替列名。不同的驱动在这方面会有不同的表现， 具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。

true | false

TRUE

useGeneratedKeys

允许 JDBC 支持自动生成主键，需要驱动兼容。 如果设置为 true 则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如 Derby）。

true | false

FALSE

autoMappingBehavior

指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示取消自动映射；PARTIAL 只会自动映射没有定义嵌套结果集映射的结果集。 FULL 会自动映射任意复杂的结果集（无论是否嵌套）。

NONE, PARTIAL, FULL

PARTIAL

autoMappingUnknownColumnBehavior

指定发现自动映射目标未知列（或者未知属性类型）的行为。

NONE, WARNING, FAILING

NONE

NONE: 不做任何反应

WARNING: 输出提醒日志 ('org.apache.ibatis.session.AutoMappingUnknownColumnBehavior'的日志等级必须设置为 WARN)

FAILING: 映射失败 (抛出 SqlSessionException)

defaultExecutorType

配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。

SIMPLE REUSE BATCH

SIMPLE

defaultStatementTimeout

设置超时时间，它决定驱动等待数据库响应的秒数。

任意正整数

Not Set (null)

defaultFetchSize

为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。

任意正整数

Not Set (null)

safeRowBoundsEnabled

允许在嵌套语句中使用分页（RowBounds）。 If allow, set the false.

true | false

FALSE

safeResultHandlerEnabled

允许在嵌套语句中使用分页（ResultHandler）。 If allow, set the false.

true | false

TRUE

mapUnderscoreToCamelCase

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

true | false

FALSE

localCacheScope

MyBatis 利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。 默认值为 SESSION，这种情况下会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地会话仅用在语句执行上，对相同 SqlSession 的不同调用将不会共享数据。

SESSION | STATEMENT

SESSION

jdbcTypeForNull

当没有为参数提供特定的 JDBC 类型时，为空值指定 JDBC 类型。 某些驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。

JdbcType enumeration. Most common are: NULL, VARCHAR and OTHER

OTHER

lazyLoadTriggerMethods

指定哪个对象的方法触发一次延迟加载。

A method name list separated by commas

equals,clone,hashCode,toString

defaultScriptingLanguage

指定动态 SQL 生成的默认语言。

A type alias or fully qualified class name.

org.apache.ibatis.scripting.xmltags.XMLLanguageDriver

callSettersOnNulls

指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这对于有 Map.keySet() 依赖或 null 值初始化的时候是有用的。注意基本类型（int、boolean等）是不能设置成 null 的。

true | false

FALSE

returnInstanceForEmptyRow

当返回行的所有列都是空时，MyBatis默认返回null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集 (i.e. collectioin and association)。（从3.4.2开始）

true | false

FALSE

logPrefix

指定 MyBatis 增加到日志名称的前缀。

Any String

Not set

logImpl

指定 MyBatis 所用日志的具体实现，未指定时将自动查找。

SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING

Not set

proxyFactory

指定 Mybatis 创建具有延迟加载能力的对象所用到的代理工具。

CGLIB | JAVASSIST

JAVASSIST (MyBatis 3.3 or above)

vfsImpl

指定VFS的实现

自定义VFS的实现的类全限定名，以逗号分隔。

Not set

useActualParamName

允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的工程必须采用Java 8编译，并且加上-parameters选项。（从3.4.1开始）

true | false

TRUE

configurationFactory

Specifies the class that provides an instance of Configuration. The returned Configuration instance is used to load lazy properties of deserialized objects. This class must have a method with a signature static Configuration getConfiguration(). (Since: 3.2.3)

A type alias or fully qualified class name.

Not set

  <!-- 配置默认的参数 -->

  <settings>

    <!-- 默认支持骆驼命名法 -->

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

  </settings>

@Select 查询数据注解

@Insert 插入数据注解

@Delete 删除数据注解

@Update 修改数据注解

@Options 选项配置

@Results 手动映射配置

@Result  ： @results中的具体的某一列的映射信息配置

package cn.zj.mybatis.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Delete;

import org.apache.ibatis.annotations.Insert;

import org.apache.ibatis.annotations.One;

import org.apache.ibatis.annotations.Options;

import org.apache.ibatis.annotations.Result;

import org.apache.ibatis.annotations.ResultMap;

import org.apache.ibatis.annotations.Results;

import org.apache.ibatis.annotations.Select;

import org.apache.ibatis.annotations.Update;

import cn.zj.mybatis.domain.User;

/**

 *

 * @Select 查询注解

 * @Insert

 *

 */

public interface UserMapper {

    @Select("select id u_id,name u_name,password u_password,age u_age from user where id = #{id}")

    @Results({

        @Result(id=true,property="id",column="u_id"),

        @Result(property="name",column="u_name"),

        @Result(property="password",column="u_password"),

        @Result(property="age",column="u_age")

    })

    User selectByPrimaryKey(Integer id);

    @Select("select * from user")

    List<User> findAll();

    @Insert("insert into user (name,password,age)values(#{name},#{password},#{age})")

    @Options(keyProperty="id",useGeneratedKeys=true)

    int insertUserInfo(User user);

    @Delete("delete from user where id = #{id}")

    int deleteByUserId(Integer id);

    @Update("update user set name = #{name} ,password = #{password},age = #{age} where id = #{id}")

    int updateUserInfoById(User user);

}

  <mappers>

     <!-- 配置具体的映射文件 ，映射xml文件-->

  <!--  <mapper resource="cn/zj/mybatis/mapper/UserMapper.xml"/>  -->

     <!-- 接口映射权限定名 -->

     <mapper class="cn.zj.mybatis.mapper.UserMapper"/>

  </mappers>

所谓的传入参数指定是Mybatis操作

(<insert><delete><update><select>)的传入参数.

方案1：将这些参数封装到一个对象里面（JavaBean/Map），再传入.

方案2：给参数设置一个@Param注解支持，而且多参数的类型要统一

问题：为什么不支持多个参数?

因为Java语法1.7以前.是不能通过反射技术获得方法的参数名的.

解决方案使用  @Param 参数注解

import java.util.Map;

import org.apache.ibatis.annotations.Param;

import cn.zj.mybatis.domain.User;

public interface UserMapper {

    /**

     * 模拟登陆操作

     * @param user 封装有账号密码的User对象

     * @return 查询结果封装的User对象

     */

    User login1(User user);

    /**

     * 模拟登陆操作

     * @param user 封装有账号密码的Map集合

     * @return 查询结果封装的User对象

     */

    User login2(Map<String, Object> map);

    User login3(@Param("username")String name,@Param("pwd")String password);

}

    @Test

    public void testlogin3() throws Exception {

        SqlSession session = MyBatidUtil.openSession();

        UserMapper mapper = session.getMapper(UserMapper.class);

        User user = mapper.login3("杨过", "yangguo");

        System.out.println(user);

    }

package cn.zj.mybatis.mapper;

import org.apache.ibatis.annotations.Param;

public interface UserMapper {

    /**

     * 动态删除数据库中指定表名

     * @param tableName 表名

     * @return

     */

    int dropTable(@Param("tableName")String tableName);

}

<?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="cn.zj.mybatis.mapper.UserMapper">

    <!--

        使用 #{} 不能使用在表名操作

     -->

    <delete id="dropTable" parameterType="String">

        <!-- drop table #{tableName} -->

        drop table ${tableName}

    </delete>

</mapper>