Mybatis框架介绍及使用

最新推荐文章于 2024-07-23 13:22:23 发布

奋斗的胡萝卜

最新推荐文章于 2024-07-23 13:22:23 发布

阅读量300

点赞数

分类专栏： java mybatis 文章标签： mybatis mysql

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.csdn.net/qq_41816068/article/details/105813389

版权

java 同时被 2 个专栏收录

1 篇文章 0 订阅

订阅专栏

mybatis

1 篇文章 0 订阅

订阅专栏

（一）框架

框架提供了可重用的公共结构的半成品。它为我们构建新的应用程序提供了极大的便利。一方面是可以拿来直接使用，更重要的是它提供了可重用的设计。

（二） Mybatis介绍及环境搭建

1.数据持久化概念

数据持久化是将内存中的数据模型转换成存储模型，以及将存储模型转换成内存中的的数据模型的统称。

2.Mybatis框架介绍

Mybat是开源的数据持久层的框架，它内部封装了通过JDBC访问数据库的操作，支持普通的SQL查询，存储过程以及高级映射。它包含配置文件（XML）和注解开发两种方式。去除了手动jdbc参数配置和结果集的检索。其主要思想把程序中大量的SQL语句抽出来，写在配置文件中。
Mybatis的前身是iBatis,是Apache的一个开源的项目，2010年迁移到Gooogle Code，并改名为Mybatis，2013年迁移到Github。

mybatis框架的优点

与JDBC相比，减少了50%以上的代码量
mybatis是最简单的持久化框架，简单易学。
灵活性较强，不会对程序或者现有数据库的设计加强影响，SQL写在XML文件中，从程序中彻底分离，降低耦合度，便于统一化管理，并可重用。
提供XML标签，并支持动态SQL语句。
提供映射标签，支持对象与数据库的ORM字段关系映射。

mybatis框架的缺点

SQL语句编写工作量较大，对于开发人员编写SQL语句的功底有一定要求。
SQL语句依赖与数据库，导致数据库移植性较差，不能随意更换数据库。

3.ORM

ORM（Object Relational Mapping）对象关系映射，是一种数据持久化技术。它在对象模型和关系型数据库之间建立起对应关系。
ORM映射关系
Mbatis通过简单地XML或者注解进行配置和原始映射，将实体类和SQL语句之间建立映射关系，是一种半自动化的ORM实现。

4.环境搭建

jdk1.8

maven

IDEA

4.1依赖

pom.xml

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
    </dependency>
</dependencies>

log4j.properties

# Set root category priority to INFO and its only appender to CONSOLE.
#log4j.rootCategory=INFO, CONSOLE            debug   info   warn error fatal
log4j.rootCategory=debug, CONSOLE, LOGFILE

# Set the enterprise logger category to FATAL and its only appender to CONSOLE.
log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE

# CONSOLE is set to be a ConsoleAppender using a PatternLayout.
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
log4j.appender.CONSOLE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %m\n

# LOGFILE is set to be a File appender using a PatternLayout.
log4j.appender.LOGFILE=org.apache.log4j.FileAppender
log4j.appender.LOGFILE.File=d:\axis.log
log4j.appender.LOGFILE.Append=true
log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
log4j.appender.LOGFILE.layout.ConversionPattern=%d{ISO8601} %-6r [%15.15t] %-5p %30.30c %x - %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>
    <properties resource="db.properties"></properties>
    <settings>
        <setting name="lazyLoadingEnabled" value="false"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>
    <typeAliases >
        <package name="cn.neepu.pojo"></package>
    </typeAliases>
    <!--配置数据源 -->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <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 class="cn.neepu.dao.UserDao"/>
         -->
       <!-- 使用配置文件
        <mapper resource="cn/neepu/dao/UserMapper.xml"/>
        -->
        
        <package name="cn.neepu.dao"></package>
    </mappers>
</configuration>

其中配置文件常用元素作用如下

configuation:配置文件根元素节点。
properties:通过resource属性从外部指定properties属性文件（database.properties）。
settings:设置Mybatis运行中的一些行为。
environments：配置Mybatis的多套运行环境，将SQL映射到不同的数据库上，该节点下可以配置多个environment节点，但是必须通过default指定默认的运行环境。
environment:配置Mybatis的一套运行环境，需要指定运行环境ID，事务管理，配置数据源等相关信息。
mappers:告诉mybatis去哪里找SQL映射文件。
mapper:mappers的子元素，具体指定SQL映射文件路径，其中resource属性的值表述了映射文件的路径（类资源路径）。当采用注解开发模式时，使用class属性来指定映射位置。
typeAliases:为Java类型命名一个别名（简称）。
注意： sqlMapConfig.xml文件有一定顺序的，节点位置若不按照顺序排位，那么XML文件会报错。

编写实体类（省略get set）

public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;
	private List<Account> accountList;
	｝

public class Role {
	private String id;
	private String roleName;
	private String roleDesc;
	private List<User> userList;
	}

public class QueryVo {
	private User user;
	private List<Integer> ids;
	}

public class Account implements Serializable{
	private Integer id;
	private Integer uid;
	private String money;
	private User user;
	}

编写UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.neepu.dao.UserMapper">
    <sql id="selectAllUser">
        SELECT * FROM user
    </sql>
    <resultMap id="accountMap" type="Account">
        <id property="id" column="ID"></id><!-- 标签内不能为空格 -->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
    </resultMap>
    <resultMap id="userMap" type="User">
        <id property="id" column="id"></id>
        <result property="username" column="username"></result>
        <result property="sex" column="sex"></result>
        <result property="address" column="address"></result>
        <result property="birthday" column="birthday"></result>
        <collection property="accountList" ofType="Account" select="cn.neepu.dao.AccountMapper.findAccountByUid" column="id">
        </collection>
    </resultMap>
    <select id="findAll" resultMap="userMap">
       SELECT * FROM user
    </select>
    <insert id="saveUser">
        <selectKey keyProperty="id" keyColumn="id" resultType="Integer" order="AFTER">
            SELECT last_insert_id();
        </selectKey>
        INSERT INTO user(username,birthday,sex,address) VALUES (#{username},#{birthday},#{sex},#{address})
    </insert>
    <update id="updateUser" parameterType="cn.neepu.pojo.User">
        UPDATE user SET address=#{address},sex=#{sex}
        WHERE username=#{username}
    </update>
    <delete id="deleteUser" parameterType="Integer">
        DELETE FROM user
        where id=#{0}
    </delete>
    <select id="findUserById" parameterType="Integer" resultType="cn.neepu.pojo.User">
        SELECT * FROM user
        WHERE id=#{0}
    </select>
    <select id="findUserByName" parameterType="String" resultType="cn.neepu.pojo.User">
        SELECT * FROM user
        WHERE username LIKE #{0}
        <!--WHERE username LIKE '%${value}%' value为固定值，不可改变,使用这种格式查询时不用传递%-->
    </select>
    <select id="findUserTotal" resultType="Integer">
        SELECT count(*) FROM user
    </select>

    <select id="findUserByQueryVo" parameterType="cn.neepu.pojo.QueryVo" resultType="cn.neepu.pojo.User">
        SELECT * FROM user
        WHERE username LIKE #{user.username}
    </select>
    <select id="findUserByCondition" resultType="User" parameterType="User">
        SELECT * FROM user
        <where>
            <if test="username!=null">
                AND username=#{username}
            </if>
            <if test="birthday!=null">
                AND birthday=#{birthday}
            </if>
            <if test="sex!=null">
                AND sex=#{sex}
            </if>
            <if test="address!=null">
                AND address=#{address}
            </if>
        </where>
    </select>
    <select id="findUserByIds" parameterType="QueryVo" resultType="User">
        <include refid="selectAllUser"></include>
        <where>
            <if test="ids!=null and ids.size()>0">
                <foreach collection="ids" open="and id in(" close=")" item="id" separator=",">
                    #{id}
                </foreach>
            </if>
        </where>
    </select>

</mapper>

编写AccountMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.neepu.dao.AccountMapper">
    <resultMap id="accountMap" type="Account">
        <id property="id" column="ID"></id><!-- 标签内不能为空格 -->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <association property="user" javaType="User" select="cn.neepu.dao.UserMapper.findUserById" column="UID" ></association>
    </resultMap>

    <select id="findAll" resultMap="accountMap" >
        SELECT * FROM account
    </select>
    <select id="findAccountByUid" resultType="Account" parameterType="Integer" >
        SELECT * FROM account
        WHERE uid=#{uid}
    </select>
</mapper>

编写RoleMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.neepu.dao.RoleMapper">
    <resultMap id="roleMap" type="Role">
        <id property="id" column="rid"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="userList" ofType="User">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            <result property="address" column="address"></result>
        </collection>
    </resultMap>
    <select id="findAllRole" resultMap="roleMap">
      SELECT u.*,r.id as rid,r.role_name,r.role_desc from role r LEFT JOIN user_role ur
      on r.id=ur.RID
      LEFT JOIN `user` u ON
      ur.uid=u.id
    </select>
</mapper>

测试类代码

package cn.neepu.test;

import cn.neepu.dao.UserMapper;
import cn.neepu.pojo.QueryVo;
import cn.neepu.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

public class TestMybatis {
	SqlSessionFactory factory;
	SqlSession session;
	InputStream in;

	@Before
	public void init() throws IOException {
		in = Resources.getResourceAsStream("sqlMapConfig.xml");
		factory = new SqlSessionFactoryBuilder().build(in);
		//userMapper = new UserMapperImpl(factory);
		session = factory.openSession();
	}

	@After
	public void destory() throws IOException {
		session.commit();
		session.close();
		in.close();
	}

	@Test
	public void testFindAll() {
		//List<User> userList =userMapper.findAll();
		List<User> userList = session.getMapper(UserMapper.class).findAll();
		//List<User> userList = session.selectList("cn.neepu.dao.UserDao.findAll");
		//System.out.println(userList);
		for (User user : userList) {
			System.out.println(user.toString());
		}

	}

	/**
	 * 测试保存对象
	 */
	@Test
	public void testSaveUser() throws IOException {
		User user = new User();
		user.setAddress("陕西");
		user.setBirthday(new Date());
		user.setUsername("王文菊");
		user.setSex("男");
		session.getMapper(UserMapper.class).saveUser(user);
		//userMapper.saveUser(user);
		System.out.println(user);

	}

	@Test
	public void testUpdateUser() {
		User user = new User();
		user.setAddress("吉林省吉林市");
		user.setBirthday(new Date());
		user.setUsername("王旭");
		user.setSex("女");
		session.getMapper(UserMapper.class).updateUser(user);
	}

	@Test
	public void testDeleteUser() {
		Integer id = 55;
		session.getMapper(UserMapper.class).deleteUser(id);
	}

	@Test
	public void testFindUserById() {
		Integer id = 88;
		User user = session.getMapper(UserMapper.class).findUserById(id);
		System.out.println(user);
	}

	@Test
	public void testFindUserByName() {
		String username = "%王%";
		List<User> userList = session.getMapper(UserMapper.class).findUserByName(username);
		for (User user : userList) {
			System.out.println(user);
		}
	}

	@Test
	public void testFindUserCount() {
		Integer usersCount = session.getMapper(UserMapper.class).findUserTotal();
		System.out.println(usersCount);
	}

	@Test
	public void testFindUserByQueryVo() {
		String username = "%王%";
		User user = new User();
		user.setUsername(username);
		QueryVo queryVo = new QueryVo();
		queryVo.setUser(user);
		List<User> userList = session.getMapper(UserMapper.class).findUserByQueryVo(queryVo);
		for (User user1 : userList) {
			System.out.println(user1);
		}
	}

	/**
	 * 测试根据条件进行查询
	 */
	@Test
	public void testFindUserByCondition() {
		User user = new User();
		user.setUsername("小二王");
		user.setSex("男");
		List<User> userList = session.getMapper(UserMapper.class).findUserByCondition(user);
		for (User u : userList) {
			System.out.println(u);
		}
	}

	/**
	 * 根据QueryVo中提供的ids来进行用户查询
	 */
	@Test
	public void testFindUserByIds() {
		QueryVo queryVo = new QueryVo();
		List<Integer> idsList = new ArrayList<Integer>();
		idsList.add(48);
		idsList.add(51);
		idsList.add(52);
		idsList.add(55);
		idsList.add(57);
		idsList.add(58);
		queryVo.setIds(idsList);
		List<User> userList=session.getMapper(UserMapper.class).findUserByIds(queryVo);
		for (User u:userList){
			System.out.println(u);
		}
	}

}

package cn.neepu.test;

import cn.neepu.dao.AccountMapper;
import cn.neepu.pojo.Account;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestAccount {
	SqlSessionFactory sqlSessionFactory;
	InputStream in;
	SqlSession sqlSession;
	@Before
	public void before()throws IOException{
		in= Resources.getResourceAsStream("sqlMapConfig.xml");
		 sqlSessionFactory=new SqlSessionFactoryBuilder().build(in);
		 sqlSession=sqlSessionFactory.openSession();
	}
	@After
	public void after()throws IOException{
		sqlSession.commit();
		sqlSession.close();
		in.close();
	}
	/**
	 * 查询所有账户信息
	 */
	@Test
	public void testFindAllAccount(){
		List<AccountUser> accountUserList=sqlSession.getMapper(AccountMapper.class).findAll();
		for(AccountUser a:accountUserList){
			System.out.println(a);
		}
	}
	/**
	 * 查询所有账户信息
	 */
	@Test
	public void testFindAllAccount2(){
		List<Account> accountList=sqlSession.getMapper(AccountMapper.class).findAll();
//		for(Account a:accountList){
//			System.out.println(a);
//		}
	}
}

package cn.neepu.test;

import cn.neepu.dao.RoleMapper;
import cn.neepu.pojo.Role;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestRole {
	SqlSessionFactory sqlSessionFactory;
	InputStream in;
	SqlSession sqlSession;

	@Before
	public void before() throws IOException {
		in = Resources.getResourceAsStream("sqlMapConfig.xml");
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
		sqlSession = sqlSessionFactory.openSession();
	}

	@After
	public void after() throws IOException {
		sqlSession.commit();
		sqlSession.close();
		in.close();
	}

	/**
	 * 查询所有角色信息
	 */
	@Test
	public void testFindAllRole() {
		List<Role> roleList = sqlSession.getMapper(RoleMapper.class).findAllRole();
		for (Role role:roleList
			 ) {
			System.out.println(role);
		}
	}
}

package cn.neepu.test;

import cn.neepu.dao.UserMapper;
import cn.neepu.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class TestUser {
	SqlSessionFactory factory;
	SqlSession session;
	InputStream in;
	//UserMapperImpl userMapper;

	@Before
	public void init() throws IOException {
		in = Resources.getResourceAsStream("sqlMapConfig.xml");
		factory = new SqlSessionFactoryBuilder().build(in);
		//userMapper = new UserMapperImpl(factory);
		session = factory.openSession();
	}

	@After
	public void destory() throws IOException {
		session.commit();
		session.close();
		in.close();
	}
	@Test
	public void testFindAll() {
		//List<User> userList =userMapper.findAll();
		List<User> userList = session.getMapper(UserMapper.class).findAll();
		//List<User> userList = session.selectList("cn.neepu.dao.UserDao.findAll");
		//System.out.println(userList);
		for (User user : userList) {
			System.out.println(user.toString());
			System.out.println(user.getAccountList());
		}

	}
}

奋斗的胡萝卜

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Mybatis框架介绍及使用

（一）框架框架提供了可重用的公共结构的半成品。它为我们构建新的应用程序提供了极大的便利。一方面是可以拿来直接使用，更重要的是它提供了可重用的设计。（二） Mybatis介绍及环境搭建1.数据持久化概念数据持久化是将内存中的数据模型转换成存储模型，以及将存储模型转换成内存中的的数据模型的统称。2.Mybatis框架介绍Mybat是开源的数据持久层的框架，它内部封装了通过JDBC访问数据...
复制链接

扫一扫