准备

依赖

<dependencies>
   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    
    <!-- mysql -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.34</version>
    </dependency>
    
    <!-- mybatis 包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.2.7</version>
        </dependency>
    
    <dependency>
        <groupId>org.bgee.log4jdbc-log4j2</groupId>
        <artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
        <version>1.16</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.13</version>
    </dependency>
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.5</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.16</version>
    </dependency>
  </dependencies>

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

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定义了数据库的连接操作 -->
      <environments default="development">
        <environment id="development">
          <transactionManager type="JDBC"/>
          <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://192.168.52.250:3306/mybatis?characterEncoding=utf-8"/>
            <property name="username" value="root"/>
            <property name="password" value="admin"/>
          </dataSource>
        </environment>
      </environments>
      <!-- 通过mappers来指定加载我们对应的mapper文件 -->
          <mappers>
            <mapper resource="mapper.xml"/>
          </mappers>
</configuration>

Mapper实现自增主键返回

<insert id="idReturn" parameterType="cn.pojo.User">
        <!-- 
            插入数时候的时候实现主键返回，获取我们插入数据的主键
            keyProperty:指定我们返回的主键，封装到哪个字段当中
            resultType:表示指定我们返回的id是什么类型的
            order:表示什么时候获取主键
            使用select  last_insert_id()来获取主键，适用于主键是自增长类型的。
         -->
        <selectKey keyProperty="id" resultType="java.lang.Integer" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
</insert>

设置别名

<typeAliases>
    <!-- 通过使用typeAliases来命名pojo对象-->
    <typeAlias type="cn.pojo.User" alias="user"/>
</typeAliases>
<typeAliases>
    <!-- 通过使用typeAliases来命名pojo对象-->
    <!-- <typeAlias type="cn.pojo.User" alias="user"/> -->
    <!-- 如果使用package的方式来命名别名，只需要拷贝我们指定的包路径就行，然后就可以做别名 -->
    <!-- 使用package这种方式来命名别名，别名就是类名，而且不区分大小写 -->
    <package name="cn.pojo"/>
</typeAliases>

Mappers映射器

<!-- 通过mappers来指定加载我们对应的mapper文件 -->
  <mappers>
   <!--  <mapper resource="mapper.xml"/> -->
   <!-- <mapper resource="mapper2.xml"/> -->
  <!--  <mapper resource="userMapper3.xml"/> -->
  <!-- 可以通过试用package的方式来指定我们所有的mapper文件的路径在哪里 -->
  <!-- 如果使用package的方式来指定包路径来扫描我们所有的mapper文件，有两点地方要注意
  第一点：我们mapper文件，一定要放到我们指定的位置 ，而且这个指定的位置一定要指定到dao接口所在的包路径
  第二点：mapper文件的命名规范，mapper文件的命名一定要与我们接口的命名相同，只不过后缀不通-->
   <package name="cn.mybatis.mapper3"/>
  </mappers>

MAVEN编译环境JDK版本插件

<build>
    <plugins>
    <!-- maven的编译插件，用于指定我们jdk的版本 -->
          <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
    </plugins>
</build>

动态SQL

IF

    <select id="queryUserList" parameterType="User" resultType="User">
        select * 
        from user
         where  1 =1 
         <if test="id !=null and id != '' ">
            and  id = #{id} 
         </if>
         <if test="address !=null and address != '' ">
            and address like '%${address}%'
         </if>
    </select>

WHERE

<!-- 动态sql使用动态sql的时候要注意，我们判断的属性字段，就是我们传递参数的属性字段-->
<select id="queryUserList" parameterType="User" resultType="User">
    select * from user
    <!-- 使用mybatis的where来对查询条件进行包装，作用是可以自动的解决查询条件的连接问题 ->
     <where>
          <if test="id !=null and id != '' ">
            and  id = #{id} 
         </if>
         <if test="address !=null and address != '' ">
            and address like '%${address}%'
         </if>
     </where>
</select>

foreach

<select id="queryUserIn" parameterType="QueryVo" resultType="User">
    select * from user 
    <!-- 使用foreach语句需要注意
    第一点:需要制定collection集合的名称与我们输入映射中的参数一致
    第二点：open属性指定我们开始的连接部分
    第三点：close属性指定我们结束部分的连接
    第四点：separator指定我们连接的连接符是什么
    第五点：item表示我们循环迭代的别名
    -->
    <where>
        <foreach collection="ids" open=" and  id in (" close=")" separator="," item="id">
            #{id}   
        </foreach>
    </where>
</select>

SQL子句

<sql id="baseSql">
    id,username,birthday,sex,address
</sql>
<select id="getUserList" parameterType="queryVo" resultType="user">
    select <include refid="baseSql"></include> 
    from user 
    where address like '%${user.address}%'
</select>

mybatis的关联查询

一：一对一关联查询

第一步，创建接口和映射文件

OrdersMapperQueryInterface接口定义

public interface OrdersMapperQueryInterface {
    List<Orders> queryOrdersJoinUsers();
}

UserMppaerQueryInterface接口定义

public interface UserMppaerQueryInterface();

OrdersMapperQueryInterface.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">
  <!-- 使用接口代理的方式来开发dao操作数据库，一定要注意，namespace这里不能再随便定义，一定要指向我们要执行的对应的接口
   -->
<mapper namespace="cn.mybatis.connectquery.OrdersMapperQueryInterface">     
</mapper>

UserMppaerQueryInterface.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">
  <!-- 使用接口代理的方式来开发dao操作数据库，一定要注意，namespace这里不能再随便定义，一定要指向我们要执行的对应的接口
   -->
<mapper namespace="cn.mybatis.connectquery.UserMppaerQueryInterface">
    
</mapper>

第二步：配置包扫描路径（SqlMapConfig.xml中配置）

第三步：接口中定义查询方法

List<Orders> queryOrdersJoinUsers();

第四步：在orders中添加user属性

第五步：定义sql语句查询

<resultMap type="orders" id="baseOrders">
    <id column="id" property="id"/>
    <result column="user_id" property="userId"/>
    <result column="number" property="number"/>
    <result column="createtime" property="createtime"/>
    <result column="note" property="note"/>
    <!-- 使用association 来定义我们一对一的关系属性
        这里的property的值，一定要是我们对应的pojo类型的属性
        javaType一定不能省，这个JavaType用于定义属性的类型
     -->
    <association property="user" javaType="cn.pojo.User" >
        <result column="username" property="username"/>
        <result column="birthday" property="birthday"/>
        <result column="sex" property="sex"/>
        <result column="address" property="address"/>
    </association>
  </resultMap>
  <select id="queryOrdersJoinUsers" resultMap="baseOrders">
    SELECT * FROM orders myord LEFT JOIN user myuser ON myord.user_id = myuser.id
  </select>

第六步：测试用例开发

@Test
public void testName() throws Exception {
    OrdersMapperQueryInterface mapper = sqlSession.getMapper(OrdersMapperQueryInterface.class);
    List<Orders> queryOrdersJoinUsers = mapper.queryOrdersJoinUsers();
    for (Orders orders : queryOrdersJoinUsers) {
        System.out.println(orders.getUser().getAddress());
        System.out.println(orders.getUser().getUsername());
    }
}

二：一对多关联查询

第一步:定义pojo类中的对应关系

第二步：定义接口中的方法

第三步：定义sql语句及返回值

    <mapper namespace="cn.mybatis.connectquery.UserMppaerQueryInterface">
        
        <resultMap type="user" id="userJoinOrders">
        <!-- 先定义user表中的所有字段属性 -->
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="birthday" property="birthday"/>
            <result column="sex" property="sex"/>
            <result column="address" property="address"/>
            <!-- 一对多的时候，通过collection来进行表示 
                在我们一对一关联查询的时候使用的是JavaType
                在我们一对多的关联查询的时候，一定要使用ofType
            -->
        <collection property="orderList" ofType="cn.pojo.Orders">
            <result column="user_id" property="userId"/>
            <result column="number" property="number"/>
            <result column="createtime" property="createtime"/>
            <result column="note" property="note"/>
        </collection>
        </resultMap>
        <!-- 实现一对多的关联查询 
        使用resultMap来自定义返回结果类型
        -->
        <select id="getUserListJoinOrders" resultMap="userJoinOrders">
            select * from user left join orders on user.id = orders.user_id
        </select>
    </mapper>

Mapper代理形式开发dao

• 开发mapper接口
• 开发mapper文件
• 配置mapper代理

    <bean class="org.mybatis.spring.mapper.MapperFactoryBean">
            <!-- 配置mapper代理对象 -->
    <property name="mapperInterface" value="cn.mybatis.mapper.UserMapper"/>
    <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>

测试方法

public class UserMapperTest {

    private ApplicationContext applicationContext;
    @Before
    public void setUp() throws Exception {
        applicationContext = new ClassPathXmlApplicationContext("classpath:spring/applicationContext.xml");
    }

    @Test
    public void testGetUserById() {
        UserMapper userMapper = applicationContext.getBean(UserMapper.class);
        User user = userMapper.getUserById(1);
        System.out.println(user);
    }

}

扫描包形式配置mapper

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <!-- 使用扫描包的形式来创建mapper代理对象 -->      
    <property name="basePackage" value="cn.mybatis.mapper"></property>
    </bean>

每个mapper代理对象的id就是类名，首字母小写

动态代理

第一步：定义接口

public interface UserDao {
    public void eat();
}

第二步：定义实现类

public class UserDaoImpl implements UserDao {
    @Override
    public void eat() {
        System.out.println("我正在吃饭呢");
    }
}

第三步：定义代理类

public class UserProxy implements InvocationHandler{
    private UserDao userDao;
    public UserProxy(UserDao userDao){
        this.userDao = userDao;
    }
    public UserDao getUserDao(){
        UserDao dao = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), this);
        return dao;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if(method.getName().equals("eat")){
            System.out.println("我先睡一觉");
            return method.invoke(userDao, args);
        }
        return method.invoke(userDao, args);
    }
}

第四步：测试用例

public class UserMain {
    public static void main(String[] args) {
        UserDao dao  = new UserDaoImpl();
        UserProxy proxy = new UserProxy(dao);
        UserDao userDao = proxy.getUserDao();
        userDao.eat();
    }
}