SSM框架 mybatis 详解 No.6

于 2017-08-29 08:18:09 发布
阅读量468 收藏 1
点赞数
文章标签： mybatis 框架 apache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lintees/article/details/77662647
版权

Mybatis是什么？

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，实质上Mybatis对ibatis进行一些改进。

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

分析原生态jdbc程序中存在的问题
原生态Jdbc程序代码

public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            //1、加载数据库驱动
            Class.forName("com.mysql.jdbc.Driver");
            //2、通过驱动管理类获取数据库链接
            connection =  DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
            //3、定义sql语句 ?表示占位符
        String sql = "select * from user where username = ?";
            //4、获取预处理statement
            preparedStatement = connection.prepareStatement(sql);
            //5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
            preparedStatement.setString(1, "王五");
            //6、向数据库发出sql执行查询，查询出结果集
            resultSet =  preparedStatement.executeQuery();
            //7、遍历查询结果集
            while(resultSet.next()){
                System.out.println(resultSet.getString("id")+"  "+resultSet.getString("username"));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            //8、释放资源
            if(resultSet!=null){
                try {
                    resultSet.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(preparedStatement!=null){
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            if(connection!=null){
                try {
                    connection.close();
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }

    }

以上代码中我们可以发现以下几点问题：

1、数据库连接频繁开启和关闭，会严重影响数据库的性能。
2、代码中存在硬编码，分别是数据库部分的硬编码和SQL执行部分的硬编码。

Mybatis框架原理（核心）

　

分析结论

1、mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的 信息。

2、mybatis通过读取配置文件信息（全局配置文件和映射文件），构造出SqlSessionFactory，即会话工厂。

3、通过SqlSessionFactory，可以创建SqlSession即会话。Mybatis是通过SqlSession来操作数据库的。

4、SqlSession本身不能直接操作数据库，它是通过底层的Executor执行器接口来操作数据库的。Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器（默认）。

5、Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中。该对象包括：SQL语句、输入参数映射信息、输出结果集映射信息。其中输入参数和输出结果的映射类型包括java的简单类型、HashMap集合对象、POJO对象类型。

Mybatis入门程序

需求

对用户信息的增删改查操作。

1、根据用户ID来查询用户信息；
2、根据用户名称来模糊查询用户信息列表；
3、添加用户

环境准备

Jdk环境：jdk1.7.0_72
Ide环境：eclipse 
数据库环境：MySQL 5.1
Mybatis：3.2.7

数据库初始化

表结构如下：

　

下载mybatis

mybaits的代码由github.com管理，下载地址：https://github.com/mybatis/mybatis-3/releases

Lib：mybatis的依赖包

Mybatis-3.2.7.jar：mybatis的核心包
Mybatis-3.2.7.pdf：mybatis的使用指南

工程搭建（三步）

第一步：创建java工程
用eclipse创建一个java工程，jdk使用1.7.0_72。

第二步：加入jar包
加入以下四部分jar包，其中junit的jar包，是非必须的。
Mybatis核心包


Mybatis依赖包


MySQL驱动包


Junit单元测试包（单元测试需要的包）


第三步：添加log4j.properties文件
Mybatis使用的日志包是log4j的，所以需要添加log4j.properties。

在classpath下创建log4j.properties如下：

日志级别在开发阶段设置成DEBUG，在生产阶段设置成INFO或者ERROR。

    # 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

编程步骤

1、创建PO类，根据需求创建；
2、创建全局配置文件SqlMapConfig.xml；
3、编写映射文件；
4、加载映射文件，在SqlMapConfig.xml中进行加载；
5、编写测试程序，即编写Java代码，连接并操作数据库。

思路：

a)读取配置文件；
b)通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
c)通过SqlSessionFactory创建SqlSession。
d)调用SqlSession的操作数据库方法。
e)关闭SqlSession。

代码开发

创建PO类

创建的po类的属性要和数据库中表的列名一致（如果表中的列名是带有下划线，那么po类中对应的的属性名要采用驼峰式命名）
User.java类如下：

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

创建SqlMapConfig.xml配置文件
在classpath下，创建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>
<!-- 配置mybatis的环境信息 -->
<environments default="development">
<environment id="development">
    <!-- 配置JDBC事务控制，由mybatis进行管理 -->
    <transactionManager type="JDBC"></transactionManager>
    <!-- 配置数据源，采用dbcp连接池 -->
    <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </dataSource>
</environment>
</environments>
</configuration>

需求开发

在classpath下，创建sqlmap文件夹。在sqlmap目录下，创建User.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">

根据用户ID来查询用户信息

编写映射文件

在User.xml中添加以下代码：

<!-- 
namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离
注意：使用mapper代理开发时，namespace有特殊且重要的作用     -->
<mapper namespace="test">
<!-- 根据用户ID，查询用户信息 -->
<!-- 
    [id]：statement的id，要求在命名空间内唯一  
    [parameterType]：入参的java类型
    [resultType]：查询出的单条结果集对应的java类型
    [#{}]： 表示一个占位符?
    [#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
 -->
<select id="findUserById" parameterType="int" resultType="cn.java.mybatis.po.User">
    SELECT * FROM USER WHERE id = #{id}
</select>
</mapper>

加载映射文件

<!-- 加载mapper -->
<mappers>
    <mapper resource="sqlmap/User.xml"/>
</mappers>

编写测试程序

public class MybatisFirst {

@Test
public void findUserByIdTest() throws Exception{

    //1、读取配置文件
    String resource = "SqlMapConfig.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //2、根据配置文件创建SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    //3、SqlSessionFactory创建SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //4、SqlSession执行statement，并返回映射结果
    //第一个参数：statement的id，建议：namespace.statementId（确保唯一）
    //第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
    User user = sqlSession.selectOne("findUserById", 1);

    //打印输出结果集
    System.out.println(user);

    //5、关闭SqlSession
    sqlSession.close();
    }
}

根据用户名称来模糊查询用户信息列表

在User.xml中，添加以下内容：

<!-- 根据用户名称模糊查询用户信息列表 -->
<!-- 
    [${}]：表示拼接SQL字符串
    [${value}]：表示要拼接的是简单类型参数。
     注意：
    1、如果参数为简单类型时，${}里面的参数名称必须为value 
    2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}    -->
<select id="findUsersByName" parameterType="String" resultType="cn.java.mybatis.po.User">
    SELECT * FROM USER WHERE username LIKE '%${value}%'
</select>

编写测试程序

@Test
public void findUsersByNameTest() throws Exception {
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
List<User> users = sqlSession.selectList("test.findUsersByName", "小明");

// 打印输出结果集
System.out.println(users);

// 5、关闭SqlSession
sqlSession.close();
}

添加用户

<!-- 添加用户 -->
<!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->
<insert id="insertUser" parameterType="cn.java.mybatis.po.User">
    INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>

编写测试程序

注意：增删改操作要对SqlSession执行commit操作。

@Test
public void insertUserTest() throws Exception {
    // 1、读取配置文件
    String resource = "SqlMapConfig.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    // 2、根据配置文件创建SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
            .build(inputStream);
    // 3、SqlSessionFactory创建SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 4、SqlSession执行statement，并返回映射结果

    //构建user参数，没有赋值的属性采取默认值
    User user = new User();
    user.setUsername("东哥1");
    user.setAddress("清河宝盛西里");

    // 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
    // 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
    sqlSession.insert("insertUser", user);

    //切记：增删改操作时，要执行commit操作
    sqlSession.commit();

    // 5、关闭SqlSession
    sqlSession.close();
}

主键返回之MySQL自增主键

思路：

MySQL自增主键，是指在insert之前MySQL会自动生成一个自增的主键。
我们可以通过MySQL的函数获取到刚插入的自增主键:
LAST_INSERT_ID()
这个函数是在insert语句之后去调用。

修改映射文件：

<!-- 添加用户之自增主键返回（selectKey方式） -->
<!-- 
        [selectKey标签]：通过select查询来生成主键
        [keyProperty]：指定存放生成主键的属性
        [resultType]：生成主键所对应的Java类型
        [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
        [last_insert_id]：MySQL的函数，要配合insert语句一起使用
-->
<insert id="insertUser" parameterType="cn.java.mybatis.po.User">
    <selectKey keyProperty="id" resultType="int" order="AFTER">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>

主键返回之MySQL函数UUID

注意：使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，长度设置成35位。

<!-- 添加用户之UUID主键返回 -->
<!-- 
    [uuid]：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改id的类型为字符类型
    注意：
        1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句
        2、显式的给ID赋值
-->
<insert id="insertUser" parameterType="cn.java.mybatis.po.User">
    <selectKey keyProperty="id" resultType="string" order="BEFORE">
        SELECT UUID()
    </selectKey>
    INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>

4.5.3.3.6主键返回之Oracle序列返回
<!-- 添加用户之sequence返回 -->
<!-- 
    通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致    
-->
<insert id="insertUser" parameterType="cn.java.mybatis.po.User">
    <selectKey keyProperty="id" resultType="int" order="BEFORE">
        SELECT user_seq.nextval() FROM dual
    </selectKey>
    INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
</insert>

删除用户

<!-- 根据ID删除用户 -->
<delete id="deleteUser" parameterType="int">
    DELETE FROM USER WHERE id= #{id}
</delete>

编写测试程序

@Test
public void deleteUserTest() throws Exception{
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
            .build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
sqlSession.delete("test.deleteUser", 30);

//切记：增删改操作时，要执行commit操作
sqlSession.commit();

// 5、关闭SqlSession
sqlSession.close();
}

修改用户

<!-- 根据传入的用户信息修改用户 -->
<update id="updateUser" parameterType="cn.java.mybatis.po.User">
    UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}
</update>

编写测试程序
@Test
public void updateUserTest() throws Exception{
// 1、读取配置文件
String resource = “SqlMapConfig.xml”;
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果

//构建user参数，没有赋值的属性采取默认值
User user = new User();
user.setId(28);
user.setUsername("东哥11");
user.setAddress("清河宝盛西里");

// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
sqlSession.update("test.updateUser", user);

//切记：增删改操作时，要执行commit操作
sqlSession.commit();

// 5、关闭SqlSession
sqlSession.close();
}

小结

parameterType和resultType

parameterType指定输入参数的java类型，可以填写别名或Java类的全限定名。
resultType指定输出结果的java类型，可以填写别名或Java类的全限定名。

#{}和${}

#{}：相当于预处理中的占位符？。
#{}里面的参数表示接收java输入参数的名称。
#{}可以接受HashMap、简单类型、POJO类型的参数。当接受简单类型的参数时，#{}里面可以是value，也可以是其他。
#{}可以防止SQL注入。

${}：相当于拼接SQL串，对传入的值不做任何解释的原样输出。
${}会引起SQL注入，所以要谨慎使用。
${}可以接受HashMap、简单类型、POJO类型的参数。当接受简单类型的参数时，${}里面只能是value。

selectOne和selectList

selectOne：只能查询0或1条记录，大于1条记录的话，会报错：

selectList：可以查询0或N条记录

Mybatis开发dao

Mybatis在项目中主要使用的地方就是开发dao（数据访问层），所以下面讲解一下mybatis开发dao的方法。有两种方式：原始dao开发方式、mapper代理开发方式（推荐）。

需求

1、根据用户ID来查询用户信息；
2、根据用户名称来模糊查询用户信息列表；
3、添加用户；

原始dao开发方式
思路

程序员需要写dao接口和dao实现类。

1、根据需求创建po类
2、编写全局配置文件
3、根据需求编写映射文件
4、加载映射文件
5、编写dao接口
6、编写dao实现类
7、编写测试代码

开发dao接口

public interface UserDao {

//根据用户ID来查询用户信息
public User findUserById(int id);
//根据用户名称来模糊查询用户信息列表
public List<User> findUsersByName(String username);
//添加用户
public void insertUser(User user);
}

开发dao实现类

SqlSession使用范围

通过入门程序，大家可以看出，在测试代码中，有大量的重复代码。所以我们第一反应就是想给它抽取出共性的部分，但是SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder有着各自的生命周期，因为这些生命周期的不同，抽取时要有针对性的处理。
所以在抽取之前，我们先来了解并总结下它们三个的生命周期。

SqlSessionFactoryBuilder

它的作用只是通过配置文件创建SqlSessionFactory，所以只要创建出SqlSessionFactory，它就可以销毁了。所以说，它的生命周期是在方法之内。

SqlSessionFactory

它的作用是创建SqlSession的工厂，工厂一旦创建，除非应用停掉，不要销毁。
所以说它的生命周期是在应用范围内。这里可以通过单例模式来管理它。
在mybatis整合spring之后，最好的处理方式是把SqlSessionFactory交由spring来做单例管理。

SqlSession

SqlSession是一个面向用户（程序员）的接口，它的默认实现是DefaultSqlSession。
Mybatis是通过SqlSession来操作数据库的。SqlSession中不仅包含要处理的SQL信息，还包括一些数据信息，所以说它是线程不安全的，因此它最佳的生命周期范围是在方法体之内。

需要向dao实现类中注入SqlSessionFactory，在方法体内通过SqlSessionFactory创建SqlSession
要注意SqlSession和SqlSessionFactory的生命周期。

public class UserDaoImpl implements UserDao {

//注入SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;
//使用构造方法来初始化SqlSessionFactory
public UserDaoImpl(SqlSessionFactory sqlSessionFactory){
    this.sqlSessionFactory = sqlSessionFactory;
}

@Override
public User findUserById(int id) {
    //通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //返回结果集
    return sqlSession.selectOne("test.findUserById", id);
}

@Override
public List<User> findUsersByName(String username) {
    //通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
    SqlSession sqlSession = sqlSessionFactory.openSession();
    return sqlSession.selectList("test.findUsersByName", username);
}

@Override
public void insertUser(User user) {
    //通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
    SqlSession sqlSession = sqlSessionFactory.openSession();
    sqlSession.insert("test.insertUser", user);
    }
}

编写测试代码

public class UserDaoTest {

//声明全局的SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;

@Before
public void setUp() throws Exception {
    // 1、读取配置文件
    String resource = "SqlMapConfig.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    // 2、根据配置文件创建SqlSessionFactory
    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}

@Test
public void testFindUserById() {
    //构造UserDao对象
    UserDao userDao = new UserDaoImpl(sqlSessionFactory);
    //调用UserDao对象的方法
    User user = userDao.findUserById(1);

    System.out.println(user);
}

@Test
public void testFindUsersByName() {
    //构造UserDao对象
    UserDao userDao = new UserDaoImpl(sqlSessionFactory);
    //调用UserDao对象的方法
    List<User> list = userDao.findUsersByName("小明");

    System.out.println(list);
}

@Test
public void testInsertUser() {
    //构造UserDao对象
    UserDao userDao = new UserDaoImpl(sqlSessionFactory);
    //构造User对象
    User user = new User();
    user.setUsername("东哥3");
    user.setAddress("清河宝盛西里3");

    //调用UserDao对象的方法
    userDao.insertUser(user);

    System.out.println(user.getId());
}

}

问题总结

原始dao开发存在一些问题：

存在一定量的模板代码。比如：
通过SqlSessionFactory创建SqlSession；
调用SqlSession的方法操作数据库；关闭Sqlsession。
存在一些硬编码。调用SqlSession的方法操作数据库时，需要指定statement的id，这里存在了硬编码。

Mapper代理开发方式（

Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。
不过要实现mapper代理的开发方式，需要遵循一些开发规范。

开发规范

1、mapper接口的全限定名要和mapper映射文件的namespace的值相同。
2、mapper接口的方法名称要和mapper映射文件中的statement的id相同；
3、mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致。
4、mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致；

通过规范式的开发mapper接口，可以解决原始dao开发当中存在的问题：

1、模板代码已经去掉；
2、剩下去不掉的操作数据库的代码，其实就是一行代码。这行代码中硬编码的部分，通过第一和第二个规范就可以解决。

编程步骤 

1、根据需求创建po类
2、编写全局配置文件
3、根据需求编写映射文件
4、加载映射文件
5、编写mapper接口
6、编写测试代码

程序编写

编写mapper映射文件

重新定义mapper映射文件UserMapper.xml（内容同Users.xml，除了namespace的值），放到新创建的目录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代理方式，它的值必须等于对应mapper接口的全限定名  -->
<mapper namespace="cn.java.mybatis.mapper.UserMapper">

<!-- 根据用户ID，查询用户信息 -->
<!-- 
    [id]：statement的id，要求在命名空间内唯一  
    [parameterType]：入参的java类型，可是是简单类型、POJO、HashMap
    [resultType]：查询出的单条结果集对应的java类型
    [#{}]： 表示一个占位符?
    [#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
 -->
<select id="findUserById" parameterType="int" resultType="cn.java.mybatis.po.User">
    SELECT * FROM USER WHERE id = #{id}
</select>


<!-- 根据用户名称模糊查询用户信息列表 -->
<!-- 
    [${}]：表示拼接SQL字符串，即不加解释的原样输出
    [${value}]：表示要拼接的是简单类型参数。
     注意：
    1、如果参数为简单类型时，${}里面的参数名称必须为value 
    2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}    -->
<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.java.mybatis.po.User">
    SELECT * FROM USER WHERE username LIKE '%${value}%'
</select>

<!-- 添加用户之自增主键返回（selectKey方式） -->
<!-- 
    [selectKey标签]：通过select查询来生成主键
    [keyProperty]：指定存放生成主键的属性
    [resultType]：生成主键所对应的Java类型
    [order]：指定该查询主键SQL语句的执行顺序，相对于insert语句，此时选用AFTER
    [last_insert_id]：MySQL的函数，要配合insert语句一起使用
 -->
<insert id="insertUser" parameterType="cn.java.mybatis.po.User">
    <selectKey keyProperty="id" resultType="int" order="AFTER">
        SELECT LAST_INSERT_ID()
    </selectKey>
    INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
</insert>

</mapper>

加载mapper映射文件

<!-- 加载mapper -->
<mappers>
    <mapper resource="sqlmap/User.xml"/>
    <mapper resource="mapper/UserMapper.xml"/>
</mappers>

编写mapper接口

public interface UserMapper {
    //根据用户ID来查询用户信息
    public User findUserById(int id);
    //根据用户名称来模糊查询用户信息列表
    public List<User> findUsersByName(String username);
    //添加用户
    public void insertUser(User user);
}

编写测试代码

public class UserMapperTest {

// 声明全局的SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;

@Before
public void setUp() throws Exception {
    // 1、读取配置文件
    String resource = "SqlMapConfig.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    // 2、根据配置文件创建SqlSessionFactory
    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}

@Test
public void testFindUserById() {
    // 创建SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 通过SqlSession，获取mapper接口的动态代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    // 调用mapper对象的方法
    User user = userMapper.findUserById(1);

    System.out.println(user);
    // 关闭SqlSession
    sqlSession.close();

}

@Test
public void testFindUsersByName() {
    // 创建SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 通过SqlSession，获取mapper接口的动态代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    // 调用mapper对象的方法
    List<User> list = userMapper.findUsersByName("小明");

    System.out.println(list);
    // 关闭SqlSession
    sqlSession.close();
}

@Test
public void testInsertUser() {
    // 创建SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();
    // 通过SqlSession，获取mapper接口的动态代理对象
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    //构造User对象
    User user = new User();
    user.setUsername("东哥4");
    user.setAddress("清河宝盛西里4");

    // 调用mapper对象的方法
    userMapper.insertUser(user);

    System.out.println(user.getId());

    //执行SqlSession的commit操作
    sqlSession.commit();
    // 关闭SqlSession
    sqlSession.close();
    }

}

Mybatis全局配置文件

SqlMapConfig.xml是mybatis的全局配置文件，它的名称可以是任意命名的。

全部配置内容

SqlMapConfig.xml的配置内容和顺序如下（顺序不能乱）：
Properties（属性）
Settings（全局参数设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境信息集合）
    environment（单个环境信息）
        transactionManager（事物）
        dataSource（数据源）
mappers（映射器）

常用配置详解

Properties

SqlMapConfig.xml文件中可以引用java属性文件中的配置信息

db.properties配置信息如下：

db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
db.username=root
db.password=root

SqlMapConfig.xml使用properties标签后，如下所示：

<!-- 通过properties标签，读取java配置文件的内容 -->
<properties resource="db.properties" />

<!-- 配置mybatis的环境信息 -->
<environments default="development">
        <environment id="development">
        <!-- 配置JDBC事务控制，由mybatis进行管理 -->
        <transactionManager type="JDBC"></transactionManager>
        <!-- 配置数据源，采用dbcp连接池 -->
        <dataSource type="POOLED">
            <property name="driver" value="${db.driver}"/>
            <property name="url" value="${db.url}"/>
            <property name="username" value="${db.username}"/>
            <property name="password" value="${db.password}"/>
        </dataSource>
    </environment>
</environments>

使用${}，可以引用已经加载的java配置文件中的信息。

**注意：**mybatis将按照下面的顺序加载属性：

Properties标签体内定义的属性首先被读取
Properties引用的属性会被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值
parameterType接收的值会最后被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值

所以说，mybatis读取属性的顺序由高到低分别是：parameterType接收的属性值、properties引用的属性、properties标签内定义的属性。

Settings

mybatis全局配置参数，全局参数将会影响mybatis的运行行为。

typeAliases

别名是使用是为了在映射文件中，更方便的去指定入参和结果集的类型，不再用写很长的一段全限定名。

mybatis支持的别名

别名  映射的类型
_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

自定义别名

SqlMapConfig.xml配置信息如下：

<!-- 定义别名 -->
    <typeAliases>
        <!-- 单个定义别名 -->
        <typeAlias type="cn.java.mybatis.po.User" alias="user"/>

        <!-- 批量定义别名（推荐） -->
        <!-- [name]：指定批量定义别名的类包，别名为类名（首字母大小写都可） -->
        <package name="cn.java.mybatis.po"/>
    </typeAliases>

mappers

<mapper resource=’’/>

使用相对于类路径的资源

如：

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

<mapper url=’’/>

使用完全限定路径

如：

<mapper url="file:///D:\workspace_spingmvc\mybatis_01\config\sqlmap\User.xml" />

<mapper class=’’/>

使用mapper接口的全限定名

如：

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

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

注册指定包下的所有映射文件

如：

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

lintees
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值