Mybatis入门

最新推荐文章于 2024-11-04 15:40:52 发布

李哈哈哈切

最新推荐文章于 2024-11-04 15:40:52 发布

阅读量1k

点赞数 10

文章标签： mybatis microsoft 数据库

本文链接：https://blog.csdn.net/2301_77165049/article/details/138377575

版权

1.框架概述

1.1 什么是框架

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法，另一种定义认为，框架是可被应用开发者定制的应用骨架。前者是从应用方面而后者是从目的方面给出的定义

简而言之，框架其实就是某种应用的半成品，就是一组组件，供你选用完成你自己的系统。

1.2 框架要解决的问题

框架要解决的最重要的一个问题是技术整合的问题，在 J2EE 的框架中，有着各种各样的技术，不同的软件企业需要从 J2EE 中选择不同的技术，这就使得软件企业最终的应用依赖于这些技术，技术自身的复杂性和技术的风险性将会直接对应用造成冲击。而应用是软件企业的核心，是竞争力的关键所在，因此应该将应用自身的设计和具体的实现技术解耦。这样，软件企业的研发将集中在应用的设计上，而不是具体的技术实现，技术实现是应用的底层支撑，它不应该直接对应用产生影响。框架一般处在低层应用平台（如 J2EE）和高层业务逻辑之间的中间层。

1.3 软件开发分层的重要性

框架的重要性在于它实现了部分功能，并且能够很好的将低层应用平台和高层业务逻辑进行了缓和。为了实现软件工程中的“高内聚、低耦合”。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。我们常见的MVC 软件设计思想就是很好的分层思想。

2. Mybatis框架

2.1 Mybatis的概述

mybatis 是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。

mybatis通过xml或注解的方式将要执行的各种 statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。[sql是通过配置]

最后mybatis框架执行sql并将结果映射为java对象并返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc 进行了封装，屏蔽了jdbc api 底层访问细节，使我们不用与jdbc api 打交道，就可以完成对数据库的持久化操作。

前身是Ibatis.开发团队转到了谷歌，后来重新命名为Mybatis

2.2 Mybatis的实现原理

mybatis 通过 xml 或注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。

2.3 Mybatis和其他技术的对比

JDBC
- SQL夹在Java代码块里，耦合度高导致硬编码内伤
- 维护不易且实际开发需求中sql是有变化，频繁修改的情况多见
Hibernate和JPA
- 长难复杂SQL，对于Hibernate而言处理也不容易
- 内部自动生产的SQL，不容易做特殊优化[需要学习HQL]。
- 基于全映射的全自动框架，大量字段的POJO进行部分映射时比较困难，导致数据库性能下降。
对开发人员而言，核心sql还是需要自己优化
sql 和 java 编码分开，功能边界清晰，一个专注业务、一个专注数据

2.3.1 原始jdbc操作（查询数据）

2.3.2 原始jdbc操作的分析

原始jdbc开发存在的问题如下：

数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能
sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变java代码
查询操作时，需要手动将结果集中的数据手动封装到实体中。插入操作时，需要手动将实体的数据设置到sql语句的占位符位置

应对上述问题给出的解决方案：

使用数据库连接池初始化连接资源
将sql语句抽取到xml配置文件中
使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射

3. Mybatis的快速入门

MyBatis官网地址：mybatis – MyBatis 3 | Introduction

3.1 Mybatis的开发步骤

①添加MyBatis的坐标

②创建user数据表

③编写User实体类

④编写映射文件UserMapper.xml

⑤编写核心文件SqlMapConfig.xml

⑥编写测试类

3.2 环境搭建

1.导入MyBatis的坐标和其他相关坐标(pom.xml文件中，<dependencies>标签内 )

<!--mybatis坐标-->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.5</version>
</dependency>
<!--mysql驱动坐标-->
<dependency>    
    <groupId>mysql</groupId>   
    <artifactId>mysql-connector-java</artifactId>    
    <version>5.1.6</version>    
    <scope>runtime</scope>
</dependency>
<!--单元测试坐标-->
<dependency>    
    <groupId>junit</groupId>    
    <artifactId>junit</artifactId>    
    <version>4.12</version>    
    <scope>test</scope>
</dependency>

2.创建user数据表

3.编写User实体

 public class User {    
   	private int id;    
   	private String username;    
   	private String password;
       //省略构造方法、get和set方法
   }

4.编写UserMapper映射文件:UserMapper.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">
<mapper namespace="userMapper">    
	<select id="findAll" resultType="com.demo.bean.User">        
		select * from User    
	</select>
</mapper>

5.编写MyBatis核心文件: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 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:///doyens"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

6.编写测试代码

  @Test  //单元测试
    public void findAllTest() throws IOException {
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("MapperConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句
        List<User> userList = sqlSession.selectList("userMapper.findAll");
        //打印结果
        System.out.println(userList);
        //释放资源
        sqlSession.close();

    }

4. Mybatis的映射文件概述

<mapper>标签

是操作数据库增删改查的根标签所有的操作都应该放在这里写
属性：namespace:命名空间标识符

<select>标签：

是查询数据库的执行标签查询的操作
id：给这个查询起一个名字
resultType:告诉框架我想返回什么结果类型（全路径名称）
select * from user 要执行的sql语句

5. MyBatis的操作

5.1 MyBatis的插入数据操作

1.编写UserMapper映射文件

<mapper namespace="userMapper">    
	<insert id="add" parameterType="com.demo.bean.User">        
		insert into user values(#{id},#{username},#{password})    
	</insert>
</mapper>

2.编写插入实体User的测试代码

  @Test  //单元测试注解
    public void assUserTest() throws IOException {
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("MapperConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句
        int insert = sqlSession.insert("userMapper.addUser", new User(null,"张三", "123456"));
        System.out.println("影响条数 " + insert);
        //提交
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

插入操作注意问题

• 插入语句使用insert标签

• 在映射文件中使用parameterType属性指定要插入的数据类型

•Sql语句中使用#{实体属性名}方式引用实体中的属性值

•插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);

•插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()

5.2 MyBatis的修改数据操作

1.编写UserMapper映射文件

<!--修改用户名为xxx的用户密码为8888-->
<mapper namespace="userMapper">    
	<update id="updateUser">
        update user set password=8888 where username=#{username}
    </update>
</mapper>

2.编写更新实体User的测试代码

 //修改用户名为张三的用户密码为8888
    @Test
    public void updateUserTest() throws IOException {
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("MapperConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句
        int i = sqlSession.update("userMapper.updateUser","张三");
        System.out.println("影响条数 " + i);
        //提交
        sqlSession.commit();
        //释放资源
        sqlSession.close();

    }

5.3 MyBatis的删除数据操作

1.编写UserMapper映射文件

<mapper namespace="userMapper">
     <delete id="deleteUser">
        delete from user where username=#{username}
    </delete>
</mapper>

2.编写删除实体User的测试代码

//    删除用户名为张三的的用户
    @Test
    public void deleteUserTest() throws IOException {
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("MapperConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句
        int delete = sqlSession.delete("userMapper.deleteUser", "张三");
        System.out.println("影响条数 " + delete);
        //提交
        sqlSession.commit();
        //释放资源
        sqlSession.close();
    }

5.4 练习一个模糊查询

1.编写UserMapper映射文件

<mapper namespace="userMapper">
     <select id="selectByName" resultType="com.zrrd.bean.User">
        select * from user where username like #{username}
    </select>
</mapper>

2.编写模糊查询实体User的测试代码

 //模糊查询姓名是两个字的用户
    @Test
    public void selectByNameTest() throws IOException {
        //加载核心配置文件
        InputStream resourceAsStream = Resources.getResourceAsStream("MapperConfig.xml");
        //获得sqlSession工厂对象
        SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(resourceAsStream);
        //获得sqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //执行sql语句
        List<User> users = sqlSession.selectList("userMapper.selectByName", "__");
        for (User user : users) {
            System.out.println("user = " + user);
        }
        sqlSession.close();
    }

5.5 使用Mybatis的注意事项

加载核心配置文件的时候文件的名字不要写错
使用sqlSession做操作的时候第一个参数是mapper文件中命名空间名字.标签的id
增删改和查询不一样必须要提交事务否则没效果
在Mppaer文件中做操作之前先思考该操作是否有参数是否有返回类型
- 如果有参数是否是自定义对象类型如果是String Integer可以省略不写
- 如果有返回类型看是否是自定义对象类型如果是String Integer可以省略不写
resultType
- 返回结果的类型
parameterType
- 参数的类型
Sql语句千万不能写错

6. 使用接口在dao中的实现

6.1 dao层的意义

dao层其实就是操作数据的层，作为后端工程师来说，我们的整体任务就是接收前端的请求，收到请求之后处理数据，将结果返回给前端，在整个流程当中，处理数据是很重要的一部分，按照规范的MVC设计理念，我们需要把处理数据这一部分单独剥离开，也就是所谓的dao层。

其实所谓的dao层就是我们将处理一个数据的地方创建一个接口在接口中定义方法 Mybatis支持直接获取接口的方式来实现增删改查的操作。

6.2 Mybatis使用dao层的写法

src下创建dao包
dao包中创建接口（注意命名规范）
修改UserMapper.xml文件中mapper标签的namespace为dao包中的接口
测试类中通过sqlSession对象调用getMapper方法传入接口获取接口对象
使用接口对象调用方法
测试效果

注意事项

mapper映射文件中的namespace一定要是dao接口的全路径名称
操作标签中的id一定是要和接口中方法名字保持一致

6.3 环境搭建

1.demo包下再创建一个dao包，该包下创建一个IUserDao接口，其代码如下：

public interface IUserDao {
    /**
     * 查询全部用户的方法
     */
    List<User> findAllUser();

    /**
     * 添加用户
     */
    int addUser(User user);

    /**
     * 修改用户
     */
    int updateUser(int id);

    /**
     * 删除用户
     */
    int deleteUserByID(int id);
}

2.重写一个核心配置文件MapperConfigDao.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>
    <!--加载其他的配置文件-->
    <properties resource="jdbcConfig.properties"></properties>
    <!--给实体类起别名 写类型时就可以简短一点-->
    <typeAliases>
        <typeAlias type="com.demo.bean.User" alias="u"></typeAlias>
    </typeAliases>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
            <!--因为上面把具体值放到了jdbcConfig.properties中，所以可以这样写，把值隐藏起来，安全-->
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="UserMapperDao.xml"/>
    </mappers>
</configuration>

3.重写用dao层接口实现的映射文件UserMapperDao.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 查询数据  这里就要连接到Dao接口-->
<mapper namespace="com.demo.dao.IUserDao">
    <!--查询全部用户 此处id值要和Dao接口中的方法名一样   u是因为改了别名-->
    <select id="findAllUser" resultType="u">
        select * from User
    </select>
    <!--添加一个用户-->
    <insert id="addUser" parameterType="u">
        insert into user values(null,#{username},#{password})
    </insert>
    <!--根据id修改用户密码为8888-->
    <update id="updateUser">
        update user set password = 8888 where id = #{id}
    </update>
    <!--根据id删除-->
    <delete id="deleteUserByID">
        delete from user where id = #{id}
    </delete>
</mapper>

4.测试代码

由单元测试坐标junit特性，注解Before方法中的内容在注解Test前执行，注解After方法中的内容在注解Test方法后执行，则可以把加载核心配置文件、创建工厂、获取session对象，得到代理接口对象等操作放在Before中，把关闭资源操作放在After中。

public class MybatisDaoTest {
    InputStream stream;
    SqlSessionFactory ssf;
    SqlSession sqlSession;
    IUserDao mapper;

    /**
     * 初始化的代码
     * @throws IOException
     */
    @Before
    public void init() throws IOException {
        //1.加载核心配置文件 获取该文件的输入流对象
        stream = Resources.getResourceAsStream("MapperConfigDao.xml");
        //2.创建SqlSession工厂对象
        ssf = new SqlSessionFactoryBuilder().build(stream);
        //3.通过工厂对象 获取SqlSession对象
        sqlSession = ssf.openSession();
        //4.直接得到代理接口对象
        mapper = sqlSession.getMapper(IUserDao.class);
    }

    /**
     * 关闭资源的方法
     */
    @After
    public void close(){
        //5.提交 增删改是属于修改表中的数据 需要提交事务
        sqlSession.commit();
        //6.释放资源
        sqlSession.close();
    }

    /**
     * 查询全部用户
     */
    @Test
    public void findAllUser(){
        List<User> userList = mapper.findAllUser();
        for (User user : userList) {
            System.out.println(user);
        }
    }

    /**
     * 添加用户
     */
    @Test
    public void addUser(){
        int i = mapper.addUser(new User(null, "唐僧", "1010"));
        System.out.println(i);
    }

    @Test
    public void updateUser(){
        int i = mapper.updateUser(5);
        System.out.println(i);
    }

    /**
     * 删除用户
     */
    @Test
    public void deleteUser(){
        int i = mapper.deleteUserByID(7);
        System.out.println(i);
    }
}

注：dao接口中的方法名要和映射文件中每个操作的id相同。

7. MyBatis核心配置文件

7.1 MyBatis核心配置文件层级关系

7.2 MyBatis常用配置解析

7.2.1 environments标签

数据库环境的配置，支持多环境配置

其中，事务管理器（transactionManager）类型有两种：

•JDBC：

这个配置就是直接使用了JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。

•MANAGED

这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。

其中，数据源（dataSource）类型有三种：

•UNPOOLED：

这个数据源的实现只是每次被请求时打开和关闭连接。

•POOLED：

这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。

•JNDI：

这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。

7.2.2 mapper标签

该标签的作用是加载映射的，加载方式有如下几种：

•使用相对于类路径的资源引用，例如：

<mapper resource="org/mybatis/builder/AuthorMapper.xml"/>

•使用完全限定资源定位符（URL），例如：

<mapper url="file:///var/mappers/AuthorMapper.xml"/>

•使用映射器接口实现类的完全限定类名，例如：

<mapper class="org.mybatis.builder.AuthorMapper"/>

•将包内的映射器接口实现全部注册为映射器，例如：

<package name="org.mybatis.builder"/>

7.2.3 Properties标签

实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties文件

7.2.4 typeAliases标签

别名是为Java 类型设置一个短的名字

<typeAlias type="com.demo.bean.User" alias="user"></typeAlias>

李哈哈哈切

关注

10
点赞
踩
29

收藏

觉得还不错? 一键收藏
1
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫