MyBatis配置与操作数据库的简单操作

最新推荐文章于 2023-07-04 16:41:40 发布
最新推荐文章于 2023-07-04 16:41:40 发布
阅读量540 收藏
点赞数
分类专栏： Mybatis 文章标签： Mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41563374/article/details/79476637
版权

MyBatis

整体流程图：

内部流程图：


1. MyBatis 概述

1.1. MyBatis 是什么?

1) 软件框架(FrameWork): 用于解决软件中的通用型问题
2) 软件中持久层框架(数据访问层):用于更好解决数据持久化问题
3) 由apache的ibatis演变而来.
想深入的可以去了解：hibernate (ORM 框架)

1.2. MyBatis 架构体系?

对于任何一个持久层框架,都应该具备接口服务,数据处理服务,基础服务等相关功能,MyBatis也不例外,它会具体如下几个层结构.
1. 接口应用层(对外提供服务)
1) 数据查询
2) 数据修改
3) 数据删除
4) 数据插入
2. 数据处理层(处理数据访问问题)
1) SQL参数映射
2) SQL解析(语法,语义)
3) SQL 执行(将sql发送到数据库端执行)
4) SQL 结果映射(例如将ResultSet中的数据存到map)
5) ....
 
3. 基础服务层
1) 连接服务
2) 事务服务
3) 缓存服务
4) 配置服务
5) .....

1.3. MyBatis 核心组件及API?

MyBatis 核心应用组件:
1. 配置文件(提供基础配置信息,例如连接配置,缓存配置,映射配置)
2. 映射文件(定义SQL映射)
3. SqlSessionFactoryBuilder (负责读取配置文件,创建SqlSessionFactory对象)
4. SqlSessionFactory(负责创建SqlSession对象)
5. SqlSession(负责连接的维护,事务的处理,类似JDBC中的Connection)
.....

2. MyBatis 编程基础

2.1. MyBatis 基本步骤

Step01:创建maven 桌面项目(Java 项目)
Step02:添加mybatis依赖以及mysql驱动依赖
Step03:创建mybatis 配置文件,映射文件
Step04:配置数据访问(配置文件),SQL映射(映射文件)
Step05:创建MyBatis API(例如SqlSession)对象,执行SQL操作.

2.2. MyBatis 编程实现

2.2.1. 数据准备

创建数据库,并在库中创建表：

create database cgb1711 character set utf8;
打开数据库：
use cgb1711;
创建表
create table blog(
 id int primary key auto_increment,
 title varchar(200) not null,
 content varchar(500) not null,
 createdTime date
) engine=innoDB;
 
向表中写入数据
insert into blog values (null,'ta','ta...',now());
insert into blog values (null,'tb','tb...',now());

2.2.2. 创建Maven桌面项目

创建maven 桌面项目,并添加依赖(mybatis,mysql驱动)
<!-- 添加mybatis依赖 -->
 <dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.2.8</version>
 </dependency>

<!-- 添加mysql驱动依赖 -->
 <dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.40</version>
 </dependency>
 <!-- 添加junit依赖 -->
 <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
 </dependency>

注意:
1) 添加依赖时注意groupId的选择?(选正规的)
2) 添加依赖以后pom.xml文件假如有错什么原因? 检测网络,检测maven配置(setting.xml)

2.2.3. 添加配置及映射文件

在src/main/resources目录下创建配置文件mybatis-configs.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:///cgb1711"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
      </dataSource>
    </environment>
  </environments>
  <!-- 配置mapper文件路径 -->
  <mappers>
     <mapper resource="mapper/BlogMapper.xml"/>
  </mappers>
</configuration>

说明:
1)配置文件的头可从官方文档进行拷贝.
2)配置文件元素没有提示是什么原因? 对应的dtd文件取不到
step02:在src/main/resources/mapper目录下创建映射文件BlogMapper.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="com.jt.blog.BlogDao">
 
</mapper>
 
说明:
1) 映射文件的命名空间用于约束元素id的唯一性.
2) 映射文件的格式最好是包结构形式
3) 映射文件内部可以定义很多元素,每个元素必须有一个唯一id,例如select
 
 
在mapper文件中添加如下元素:
 
查询所有blog数据
<select id="findBlogs" resultType="map">
         select * from blog
</select>
 
根据id查询blog数据
<select id="findBlogById" resultType="map">
         select *
         from blog 
         where id=#{id}
</select>
 
限制查询blog元素
<select id="findPageBlogs"
            resultType="map">
          select *
          from blog
          limit #{array[0]},#{array[1]}
</select>
 
向表中插入数据元素定义
 
   <insert id="insertObject">
          insert into blog
          (id,title,content,createdTime)
          values
          (null,#{array[0]},#{array[1]},now())
    </insert>
 
修改表中数据元素定义
 
<update id="updateObject">
         update blog 
         set title=#{array[0]},
             content=#{array[1]}
         where id=#{array[2]}
    </update>
 
删除表中元素元素定义
 
  <delete id="deleteObject">
         delete
         from blog
         where id=#{id}
    </delete>

2.2.4. 编写代码执行查询测试

基于BlogMapper.xml文件中元素的定义,添加测试类及相关方法.
 
编写测试类并添加测试方法
public class TestBlog01 {
private SqlSessionFactory factory;
}
 
测试类中添加初始化factory的方法
@Before
public void init()throws IOException{
//初始化SqlSessionFactory
factory=new SqlSessionFactoryBuilder()
.build(Resources.getResourceAsStream(
"mybatis-configs.xml"));
}
 
测试类中添加查询所有blogs的方法
@Test
public void testFindBlogs(){
//1.创建SqlSession对象(相当于创建一个连接)
SqlSession session=factory.openSession();
//2.执行查询操作(selectList("命名空间"+"元素id"))
List<Object> list=session.selectList(
"com.jt.blog.BlogDao.findBlogs");
for(Object o:list){
System.out.println(o);
}
//3.释放资源(类似关闭连接)
session.close();
}
 
测试类中添加根据id执行查询方法
 
@Test
public void testFindBlogById(){
//1.创建session对象
SqlSession session=
factory.openSession();
//2.执行sql操作
String statement="com.jt.blog.BlogDao.findBlogById";
Map<String,Object> map=
session.selectOne(statement,1);
System.out.println(map);
//3.释放资源(关闭session对象)
session.close();
}
 
测试类中添加分页查询方法
 
@Test
public void testFindPageBlogs(){
//1.创建session对象
SqlSession session=
factory.openSession();
//2.执行sql操作?????
String statement="com.jt.blog.BlogDao.findPageBlogs";
Object parameter=new Object[]{0,4};
List<Map<?,?>> list=
session.selectList(statement, parameter);
for(Map<?,?>map:list){
System.out.println(map);
}
//3.释放资源(关闭session对象)
    session.close();
};
 
 
测试类中添加插入数据的方法
@Test
public void testInsertObject(){
//1.创建session
SqlSession session=factory.openSession();
//2.执行sql
String statement="com.jt.blog.BlogDao.insertObject";
Object parameter=new Object[]{"te","te..."};
int rows=session.insert(statement, parameter);
System.out.println("insert.rows="+rows);
session.commit();
//3.关闭session
session.close();
}
 
测试类中添加修改方法
@Test
public void testUpdateObject(){
//1.创建session
SqlSession session=factory.openSession();
//2.执行sql
String statement="com.jt.blog.BlogDao.updateObject";
Object parameter=new Object[]{"taa","taa...",1};
int rows=session.update(statement, parameter);
System.out.println("update.rows="+rows);
session.commit();
//3.关闭session
session.close();
}
 
测试类中添加删除方法
@Test
public void testDeleteObject(){
//1.创建session
SqlSession session=factory.openSession();
//2.执行sql
String statement="com.jt.blog.BlogDao.deleteObject";
Object parameter=7;
int rows=session.delete(statement, parameter);
session.commit();
System.out.println("delete.rows="+rows);
//3.关闭session
session.close();
}

3. MyBatis 编程进阶

本小节中会从mybatis编程的另一个角度(例如基于接口方式等)实现对数据库中数据的操作.

3.1. 基本步骤

Step01: 创建maven桌面项目并添加依赖
Step02: 创建配置文件config.propertis(内容为数据库相关)
Step03: 创建mybatis核心配置文件mybatis-configs.xml文件
Step04: 配置Mybatis基础数据服务(properties,datasource,mapper)
Step05: 创建映射文件BlogMapper.xml
Step06: 创建实体类Blog(与表对应,可用于封装表中数据)
Step07: 创建BlogDao接口,并添加相关方法.
Step08: 配置BlogMapper映射文件,添加相关元素.
Step09: 基于BlogDao接口与映射文件实现CRUD操作

3.2. 编程实现

3.2.1. 创建Maven桌面项目

创建maven桌面项目并添加依赖

<!-- 添加mybatis依赖 -->

 <dependency>

  <groupId>org.mybatis</groupId>

  <artifactId>mybatis</artifactId>

  <version>3.2.8</version>

 </dependency>

 

 <!-- 添加mysql驱动依赖 -->

 <dependency>

   <groupId>mysql</groupId>

   <artifactId>mysql-connector-java</artifactId>

   <version>5.1.40</version>

 </dependency>

 

  <!-- 添加junit依赖 -->

 <dependency>

   <groupId>junit</groupId>

   <artifactId>junit</artifactId>

   <version>4.12</version>

 </dependency>

3.2.2. 创建config.properties文件

在src/main/resource目录下创建config.properties文件,此文件中定义
系统中的一些常用配置信息,例如访问数据库的相关信息,其内容如下
 
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/cgb1711
username=root
password=root

3.2.3. 创建mybatis核心配置文件

在src/main/resources目录下创建mybatis-configs.xml文件,并配置数据源等相关信息,数据信息从config.properties文件读取.
 
<?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文件-->
  <properties resource="config.properties"/>
  <!-- 配置初始化环境(连接) -->
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url"  value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
</configuration>

3.2.4. 创建Blog实体对象

创建Blog类实现与数据库中Blog表实现映射.
 
public class Blog {
private Integer id;
private String title;
private String content;
private Date createdTime;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public Date getCreatedTime() {
return createdTime;
}
public void setCreatedTime(Date createdTime) {
this.createdTime = createdTime;
}
@Override
public String toString() {
return "Blog [id=" + id + ", title=" + title + ", content=" + content + ", createdTime=" + createdTime + "]";
}
}

3.2.5. 创建BlogDao接口

创建数据访问接口,并添加相关方法
package com.jt.dao;
import java.util.List;
import org.apache.ibatis.annotations.Param;
import com.jt.entity.Blog;
public interface BlogDao {
 /***
  * 根据id进行对象查找
  * @param id
  * @return
  */
 Blog findBlogById(Integer id);
 List<Blog> findPageBlogs(
     @Param("offset")Integer offset,
     @Param("pageSize")Integer pageSize);
 int insertObject(Blog blog);
 int updateObject(Blog blog);
 int deleteObject(Integer id);
}

3.2.6. 创建BlogMapper映射文件

<?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="com.jt.dao.BlogDao">
 
</mapper>
 
 
BlogMapper文件中添加与BlogDao接口对应的映射元素
 
添加基于ID进行查询的元素
<select id="findBlogById"
           parameterType="int"
           resultType="blog">
           select *
           from blog
           where id=#{id}
   </select>
 
添加分页查询元素
 
  <select id="findPageBlogs"
           resultType="blog">
           select *
           from blog
           limit #{offset},#{pageSize}
   </select>
 
添加insert元素
   <insert id="insertObject"
           parameterType="blog">
           insert into blog
           (id,title,content,createdTime)
           values
           (null,#{title},#{content},now())
   </insert>
 
添加更新元素
   <update id="updateObject"
           parameterType="blog">
           update blog
           set title=#{title},content=#{content}
           where id=#{id}
   </update>
 
添加删除元素
<delete id="deleteObject"
           parameterType="int">
           delete from blog where id=#{id}
</delete>
 
最后在mybatis-configs.xml中添加BlogMapper文件

3.2.7. 创建单元测试类执行测试

创建单元测试类,并添加相关方法实现基于Dao接口方式的数据库操作.
 
public class TestBlog01 {
 
private SqlSessionFactory factory;
@Before
public void init()throws IOException{
factory=new SqlSessionFactoryBuilder()
.build(Resources.getResourceAsStream(
"mybatis-configs.xml"));
}
@Test
public void testFindBlogById(){
//1.创建session
    SqlSession session=factory.openSession();
//2.执行sql
    //2.1获取dao对象
    BlogDao dao=
    session.getMapper(BlogDao.class);
    //2.2执行dao中方法
    Blog blog=dao.findBlogById(1);
    System.out.println(blog);
//3.关闭session
    session.close();
}
@Test
public void testFindPageBlogs(){
//1.创建session
SqlSession session=factory.openSession();
//2.执行sql
//2.1获取dao对象
BlogDao dao=
session.getMapper(BlogDao.class);
//2.2执行dao中方法
List<Blog> list=dao.findPageBlogs(0, 2);
for(Blog b:list){
System.out.println(b);
}
//3.关闭session
session.close();
}
@Test
public void testInsertObject(){
//1.创建session
SqlSession session=factory.openSession();
//2.执行sql
//2.1获取dao对象
BlogDao dao=
session.getMapper(BlogDao.class);
//2.2执行dao中方法
Blog blog=new Blog();
blog.setTitle("te");
blog.setContent("te...");
dao.insertObject(blog);
session.commit();
//3.关闭session
session.close();
}
}
leewust1991
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【MyBatis】MyBatis操作数据库
haoshaokang_的博客
03-04 351
MyBatis是一个持久层框架（用于实现数据持久化的框架），它的底层也是基于JDBC的，不过用MyBatis比直接用JDBC操作数据库要方便很多。MyBatis是一个ORM（Object Relational Mapping）框架，即对象关系映射框架，映射关系：数据表–>>映射成一个类一条记录–>>映射成一个对象表中的字段–>>映射成类中的属性由于MyBatis实现了这层映射关系，我们可以像操作对象一样来操作数据表。
My Batis配置文件
HDW1203的博客
05-08 933
mybatis配置文件两大类：1.mybatis主配置文件；2.mybatis的mapper文件； 1、mybatis主配置文件，提供mybatis全局设置的。包含的内容 日志，数据源，mapper文件位置。 2、mapper文件：写sql语句的。一个表一个mapper文件 1.Settingsbuf settings是mybatis的全局设置，影响整个mybatis的运行。这个设置一般使用默认值。 2.配置环境 environments：环境标签，在他里面可以配置多个environment 属性：id 自
MyBatis操作数据库
weixin_44985964的博客
03-11 2979
if>标签。
MyBatis—操作数据库
m0_74365243的博客
07-04 2120
MyBatis 不仅仅是一个 ORM 框架，它更是一种让你和数据库之间建立感情的艺术, 快点进来学习吧~~
MyBatis操作数据库实现
qq_42108331的博客
06-09 2166
MyBatis操作数据库实现（注解方式和XML文件方式）
使用Mybatis框架操作数据库
01-19
在使用Mybatis操作数据库时，首先需要进行基本的配置。这通常包括创建Mybatis的核心配置文件（mybatis-config.xml），在这个文件中，我们可以配置数据源、事务管理器、环境等信息。数据源定义了连接数据库的信息，如...
SpringBoot + mybatis + postgresql数据库操作程序
最新发布
06-04
Mybatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的POJOs(Plain Old Java Objects，普通的Java对象)映射成数据库中的记录。 3. **PostgreSQL**： PostgreSQL是一种强大的开源关系型数据库管理系统...
mybatis对数据库基本操作
10-11
综上所述，MyBatis 作为一个轻量级的 ORM 框架，提供了丰富的功能，使得数据库操作变得简单高效。无论是简单的 CRUD 操作，还是复杂的业务查询，MyBatis 都能轻松应对。通过深入理解和灵活运用 MyBatis，可以大大...
基于mybatis 的简单数据库操作
05-25
基于MyBatis进行简单的数据库操作，涉及的知识点广泛，包括MyBatis的基本概念、配置、映射文件、动态SQL以及事务管理等。 1. **MyBatis简介** MyBatis 是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级...
mybatis:使用mybatis封装一些数据库操作
06-01
总结，MyBatis作为一个强大的持久层框架，使得数据库操作变得更加简单和高效。通过合理封装，我们可以轻松地使用MyBatis来处理SQLite和MySQL的数据库操作，实现Java应用程序的数据访问层。在实际项目中，结合Spring...
用mybatis对对数据库进行操作
qq_48856939的博客
03-10 372
一.Mybatis简介 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。 MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
通过 MyBatis 操作数据库
weixin_56666956的博客
04-18 113
定 MyBatis 应该扫描的 TypeHandler 所在的包名。B、MyBatis是一个轻量级的持久层框架，使用XML文件来描述SQL语句和映射关系，通过SQL语句与Java方法之间的映射来实现数据的持久化操作。A、JPA是Java EE的一部分，提供了一种对象关系映射（ORM）技术，将Java类映射到关系型数据库表中。= classpath*:mapper/**/*.xml (mybatis映射文件位置)指定 MyBatis 应该扫描的类型别名所在的包名。2、Jpa和MyBatis的区别。
MyBatis 操作数据库
qq15035899256的博客
08-30 910
本文是MyBatis的学习，认识到MyBatis带给我们的便利，更简单的去操作数据库，MyBatis的两种使用方式：注解 / XML配置文件。之后的学习内容将持续更新！！！
利用MyBatis框架操作数据库
m0_62404808的博客
04-01 1591
MyBatis是一个持久化框架，支持自定义SQL、存储过程以及高级映射，是一个优秀的ORM（对象关系映射）的框架。MyBatis框架的特点就是比较灵活。
利用Mybatis实现对数据库的操作
qq_50074343的博客
06-05 764
问题：怎样利用Mybatis实现对数据库的操作？（具体步骤）【个人总结可能理解稍微有点错误，请看到这篇文章的大佬·多多指正，十分感谢】①首先创建一个maven项目②在pom.xml中导入需要的jar包的代码，这里我们需要导入Mybatis,mysql,junit，（注：这个代码直接到Maven Central Repository Search 中搜索粘贴复制即可）如图所示：③书写数据库表对应的实体对象，来存放对数据库进行操作的结果或者便于后面其他类修改或获取该对象属性值。还是结合图来看（我是针对我mysq
MyBatis配置
qq_42448128的博客
08-01 860
首先MyBatis是持久层的框架，常用来替代JDBC的方案之一框架组成，三基本要素。
JavaEE期末复习题库
12-30
- `<mapper>`元素是MyBatis配置文件的根元素，其`namespace`属性为这个映射器（Mapper）提供了唯一的命名空间标识，便于管理和定位不同的数据库操作。 2. **判断题** - 错误：`<mappers>`元素不是配置文件的根...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值