[关闭]
@nextleaf 2018-07-18T18:58:23.000000Z 字数 11025 阅读 663

【1】MyBatis框架及入门

MyBatis 持久层


mybatis的执行流程

mybatis框架是一个持久层框架。mybatis可以让开发者的主要精力放在sql上,通过mybatis提供的映射方式,自由灵活的生成满足需要的sql语句。MyBatis可以将向preparedStatement中的输入参数自动进行输入映射,将查询结果集灵活映射成java对象(输出映射)。下面在整体上把握一下mybatis框架,总结一下mybatis的执行流程。mybatis的执行流程
从图中可以看出,mybatis中首先要在配置文件中配置一些东西,然后根据这些配置去创建一个会话工厂,再根据会话工厂创建会话,会话发出操作数据库的sql语句,然后通过执行器操作数据,再使用mappedStatement对数据进行封装。这就是整个mybatis框架的执行情况。

入门mybatis

1、mybatis环境准备

mybatis运行环境

mybatis运行环境主要是指mybatis的jar包,mybatis已经将它的各个版本托管到github上了,大家可以去github上下载。
mybatis的jar包包括一个核心包和几个依赖包,我们全部导入到工程中即可。然后就是mysql的驱动包,也要导入到工程中总共需要导入的jar包
如果时候maven工程,需要引入MyBatis依赖

  1. <!--mybatis依赖 -->
  2. <dependency>
  3. <groupId>org.mybatis</groupId>
  4. <artifactId>mybatis</artifactId>
  5. <version>3.4.6</version>
  6. </dependency>
  7. <!-- mybatis/spring包 -->
  8. <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
  9. <dependency>
  10. <groupId>org.mybatis</groupId>
  11. <artifactId>mybatis-spring</artifactId>
  12. <version>1.3.2</version>
  13. </dependency>
  14. <!-- mysql驱动包 -->
  15. <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  16. <dependency>
  17. <groupId>mysql</groupId>
  18. <artifactId>mysql-connector-java</artifactId>
  19. <version>8.0.11</version>
  20. </dependency>

log4j配置文件

从上面的jar包中可以看出,mybatis的依赖包中有很多日志包,既然mybatis依赖log4j,那我们首先要建立一个log4j.properties文件,这个可以在官方的文件中拷贝下,如下:

  1. # Global logging configuration
  2. # developer-->DEBUG productor-->INFO or ERROR
  3. log4j.rootLogger=DEBUG, stdout
  4. # MyBatis logging configuration...
  5. log4j.logger.org.mybatis.example.BlogMapper=TRACE
  6. # Console output...
  7. log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  8. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  9. log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

全局配置文件

mybatis需要配置一个全局配置文件SqlMapConfig.xml,这个文件是用来配置mybatis的运行环境,即数据源、事务等。我们也可以从官方的例子中拷贝一份,然后做一下修改:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  6. <!-- 和Spring整合后environment配置都会被干掉 -->
  7. <environments default="development">
  8. <environment id="development">
  9. <!-- 使用jdbc事务管理,目前由mybatis来管理 -->
  10. <transactionManager type="JDBC" />
  11. <!-- 数据库连接池,目前由mybatis来管理 -->
  12. <dataSource type="POOLED">
  13. <property name="driver" value="com.mysql.jdbc.Driver" />
  14. <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
  15. <property name="username" value="root" />
  16. <property name="password" value="root" />
  17. </dataSource>
  18. </environment>
  19. </environments>
  20. <mappers>
  21. <mapper resource="sqlmap/User.xml" />
  22. </mappers>
  23. </configuration>

以上这些环境配置(标签中的内容在以后和Spring整合后,都会交给Spring来管理,现在暂时交给 mybatis来管理)中,修改成自己数据库相对应的情况即可,标签用来配置映射文件的,这些映射文件是针对不同的pojo的,这个示例中只操作一个User对象,所以只有一个配置文件,在sqlmap目录下的User.xml,在下文中可以看到。最后来看一下整个环境的结构:
结构
接下来就开始开发示例程序了

编写程序

首先我们得有一个pojo,在mybatis.po包中新建一个User.java类

  1. package com.vo;
  2. import java.util.Date;
  3. public class User {
  4. private Integer id;
  5. private String username;
  6. private Date birthday;
  7. private String sex;
  8. private String address;
  9. public User(String username, Date birthday, String sex, String address) {
  10. this.username = username;
  11. this.birthday = birthday;
  12. this.sex = sex;
  13. this.address = address;
  14. }
  15. public User(Integer id, String username, Date birthday, String sex, String address) {
  16. this.id = id;
  17. this.username = username;
  18. this.birthday = birthday;
  19. this.sex = sex;
  20. this.address = address;
  21. }
  22. public User() {}
  23. public Integer getId() {return id;}
  24. public String getUsername() {return username;}
  25. public Date getBirthday() {return birthday;}
  26. public String getSex() {return sex;}
  27. public String getAddress() {return address;}
  28. public void setId(Integer id) {this.id = id;}
  29. public void setUsername(String username) {this.username = username;}
  30. public void setBirthday(Date birthday) {this.birthday = birthday;}
  31. public void setSex(String sex) {this.sex = sex;}
  32. public void setAddress(String address) {this.address = address;}
  33. }

对应数据库建表语句

  1. use mybatis
  2. drop table if exists user;
  3. create table user
  4. (
  5. id int primary key not null auto_increment,
  6. username varchar(40),
  7. birthday date,
  8. sex char(1),
  9. address varchar(255)
  10. );
  11. insert into user(username,birthday,sex,address) values("倪升武","1990-09-19","男","同济大学");
  12. insert into user(username,birthday,sex,address) values("张三2","1990-09-19","男","同济大学");
  13. /*自己多加几个*/

根据用户id查询用户信息

首先得创建配置文件User.xml,并在配置文件中创建sql语句,如下:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="test">
  6. <!-- 需求:通过id查询用户 -->
  7. <select id="findUserById" parameterType="int" resultType="mybatis.po.User">
  8. select * from user where id = #{id}
  9. </select>
  10. </mapper>

来简单解释下该配置文件中一些参数的作用:

<select>标签:用于执行数据库查询的,所有关于查询的都使用该标签。
id属性:标识映射文件中的sql,将sql语句封装到mappedStatement对象中,即statement的id,下面执行数据库的时候需要用到这个id。
#{}:表示一个占位符,用来接收输入参数的。
#{id}:id标识接收输入的参数,参数名称就是id,如果输入参数是简单类型,那么#{}中的参数名可以任意,可以value或者其他名称。
parameterType:指定输入参数的类型,这个要和数据库中的保持一致。
resultType:指定输出结果的类型,即查询结果所映射的java对象。

有了User.xml配置文件后,需要在全局配置文件SqlMapConfig.xml中添加这个映射,上面已经添加过了,即:

  1. <mappers>
  2. <mapper resource="sqlmap/User.xml" />
  3. </mappers>

接下来就是写测试类:

  1. import java.io.IOException;
  2. import java.io.InputStream;
  3. import org.apache.ibatis.io.Resources;
  4. import org.apache.ibatis.session.SqlSession;
  5. import org.apache.ibatis.session.SqlSessionFactory;
  6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  7. import org.junit.Test;
  8. import com.vo.User;
  9. public class MybatisFirst {
  10. //因为接下来的测试代码中,获取sqlSession这部分都相同,所以抽取成一个方法
  11. public SqlSession getSession() throws IOException {
  12. String resource = "SqlMapConfig.xml"; //mybatis配置文件
  13. //得到配置文件的流
  14. InputStream inputStream = Resources.getResourceAsStream(resource);
  15. //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
  16. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  17. //通过工厂得到SqlSession
  18. SqlSession sqlSession = sqlSessionFactory.openSession();
  19. return sqlSession;
  20. }
  21. //根据id查询用户的信息,得到一条记录的结果
  22. @Test
  23. public void findUserById() throws IOException {
  24. SqlSession sqlSession = getSession(); //调用上面的方法获取sqlSession
  25. //通过SqlSession操作数据库
  26. //第一个参数:映射文件中statement的id,= namespace + statement的id
  27. //第二个参数:指定和映射文件中所匹配的parameterType类型的参数
  28. //selectOne表示查询出一条记录进行映射
  29. User user = sqlSession.selectOne("test.findUserById", 1);
  30. System.out.println(user);
  31. //释放资源,最好放在finally中,这里只是测试程序,就不弄了
  32. sqlSession.close();
  33. }
  34. }

mybatis有个特点,就是要执行什么语句,都写在配置文件中,需要传入或者输出什么参数类型也写在配置文件中,在java中只要对应那个配置传入我们想要的参数或者接受输出参数即可

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

使用mybatis开发,流程都一样,先在User.xml中添加配置:

  1. <mapper namespace="test">
  2. <!-- 省略其他 -->
  3. <!-- 根据用户名称模糊查询用户信息,可能返回多条 -->
  4. <select id="findUserByName" parameterType="java.lang.String" resultType="mybatis.po.User">
  5. select * from user where username like '%${value}%'
  6. </select>
  7. </mapper>

resultType:这里虽然是查询多条记录,但是resultType指定的就是单条记录所映射的java对象类型。
${}:表示拼接sql串,将接收到的参数的内容不加任何的修饰拼接在sql中,${}中只能使用value,但是使用${}来拼接sql,可能会引起sql注入,所以不建议使用这种方法。

这里使用${}来拼接sql是为了后面java程序中直接输入方便(比如我模糊查询“张三”,就不用输入“%张三%”了),但是有sql注入的隐患。如果安全一点,还是使用#{}来接收参数,不过此时的话,java程序中输入参数就得是“%张三%”了。下面看下java程序:

  1. package test;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.util.List;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.Test;
  10. import com.vo.User;
  11. public class MybatisFirst {
  12. //因为接下来的测试代码中,获取sqlSession这部分都相同,所以抽取成一个方法
  13. public SqlSession getSession() throws IOException {
  14. String resource = "SqlMapConfig.xml"; //mybatis配置文件
  15. //得到配置文件的流
  16. InputStream inputStream = Resources.getResourceAsStream(resource);
  17. //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
  18. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  19. //通过工厂得到SqlSession
  20. SqlSession sqlSession = sqlSessionFactory.openSession();
  21. return sqlSession;
  22. }
  23. //省略不相关代码
  24. //根据用户名称模糊查询用户列表
  25. @Test
  26. public void findUserByName() throws IOException {
  27. SqlSession sqlSession = getSession();
  28. //selectList表示查询出一个列表(多条记录)进行映射
  29. List<User> list = sqlSession.selectList("test.findUserByName", "张三");
  30. System.out.println(list);
  31. //释放资源,最好放在finally中,这里只是测试程序,就不弄了
  32. sqlSession.close();
  33. }
  34. }

添加用户

首先完成添加用户的配置文件:

  1. <mapper namespace="test">
  2. <!-- 省略不相关配置 -->
  3. <!-- 添加用户 -->
  4. <insert id="insertUser" parameterType="mybatis.po.User">
  5. insert into user(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address})
  6. <!-- 将插入数据的主键返回,返回到user对象中 -->
  7. <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">
  8. select last_insert_id()
  9. </selectKey>
  10. <!--
  11. <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">
  12. select uuid()
  13. </selectKey>
  14. -->
  15. </insert>
  16. </mapper>

<insert>标签:用于执行数据库查询的,所有关于查询的都使用该标签。
parameterType:要传入一个具体的pojo(包括用户信息)
#{}中指定pojo的属性名,接收到pojo对象的属性值,mybatis通过OGNL获取对象的属性值。
<selectKey>标签:用来返回插入数据的主键的,实际中如果有获得主键的需要就可以使用它。
select last_insert_id():是sql函数,表示得到刚刚insert进去记录的主键值,只适用于自增主键。
keyProperty:表示将查询到主键值设置到上面parameterType指定的对象的哪个属性。
order:表示select last_insert_id()的执行顺序,是相对于insert语句来说的。
resultType:表示select last_insert_id()的结果类型。

添加用户的java代码:

  1. package test;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.util.Date;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.Test;
  10. import com.vo.User;
  11. public class MybatisFirst {
  12. //因为接下来的测试代码中,获取sqlSession这部分都相同,所以抽取成一个方法
  13. public SqlSession getSession() throws IOException {
  14. String resource = "SqlMapConfig.xml"; //mybatis配置文件
  15. //得到配置文件的流
  16. InputStream inputStream = Resources.getResourceAsStream(resource);
  17. //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
  18. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  19. //通过工厂得到SqlSession
  20. SqlSession sqlSession = sqlSessionFactory.openSession();
  21. return sqlSession;
  22. }
  23. //省略不相关代码
  24. //添加用户信息
  25. @Test
  26. public void insertUser() throws IOException {
  27. SqlSession sqlSession = getSession();
  28. User user = new User("倪升武", new Date(), "男", "同济大学");
  29. sqlSession.insert("test.insertUser", user); //添加一项
  30. //提交事务
  31. sqlSession.commit();
  32. System.out.println(user.getId()); //获取刚刚添加的id
  33. //释放资源,最好放在finally中,这里只是测试程序,就不弄了
  34. sqlSession.close();
  35. }
  36. }

更新用户和删除用户

  1. <mapper namespace="test">
  2. <!-- 省略不相关配置 -->
  3. <!-- 删除用户 -->
  4. <delete id="deleteUser" parameterType="java.lang.Integer">
  5. delete from user where id=#{id}
  6. </delete>
  7. <!-- 更新用户 -->
  8. <update id="updateUser" parameterType="mybatis.po.User">
  9. update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address} where id=#{id}
  10. </update>
  11. </mapper>
  1. package test;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.util.Date;
  5. import org.apache.ibatis.io.Resources;
  6. import org.apache.ibatis.session.SqlSession;
  7. import org.apache.ibatis.session.SqlSessionFactory;
  8. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  9. import org.junit.Test;
  10. import com.vo.User;
  11. public class MybatisFirst {
  12. //因为接下来的测试代码中,获取sqlSession这部分都相同,所以抽取成一个方法
  13. public SqlSession getSession() throws IOException {
  14. String resource = "SqlMapConfig.xml"; //mybatis配置文件
  15. //得到配置文件的流
  16. InputStream inputStream = Resources.getResourceAsStream(resource);
  17. //创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
  18. SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  19. //通过工厂得到SqlSession
  20. SqlSession sqlSession = sqlSessionFactory.openSession();
  21. return sqlSession;
  22. }
  23. //省略不相关代码
  24. //删除用户信息
  25. @Test
  26. public void deleteUser() throws IOException {
  27. SqlSession sqlSession = getSession();
  28. //传入id,删除用户
  29. sqlSession.delete("test.deleteUser", 16);
  30. //提交事务
  31. sqlSession.commit();
  32. //释放资源,最好放在finally中,这里只是测试程序,就不弄了
  33. sqlSession.close();
  34. }
  35. //更新用户信息
  36. @Test
  37. public void updateUser() throws IOException {
  38. SqlSession sqlSession = getSession();
  39. User user = new User("倪升武", new Date(), "男", "同济大学");
  40. user.setId(9);
  41. //更新用户
  42. sqlSession.update("test.updateUser", user);
  43. //提交事务
  44. sqlSession.commit();
  45. //释放资源,最好放在finally中,这里只是测试程序,就不弄了
  46. sqlSession.close();
  47. }
  48. }

到这里mybatis的入门程序就写完了,从上面的程序来看,mybatis的基本操作还是挺简便的。主要要搞清楚mybatis的一个执行流程就比较好理解了。入门就总结这么多吧

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注