黑马程序员mybatis教程第二天：mapper代理开发和逆向工程

合集下载

mybatis入门教程

mybatis入门教程MyBatis是一种开源的持久层框架，它可以帮助我们简化数据库操作的过程。

本教程将介绍如何使用MyBatis进行基本的数据访问操作。

第一步：创建数据库和表首先，我们需要创建一个数据库和一个表来存储数据。

假设我们创建了一个名为"mybatis_demo"的数据库，并在其中创建了一个名为"users"的表，该表包含id、name和age三个字段。

第二步：引入MyBatis依赖在使用MyBatis之前，我们需要在项目的pom.xml文件中引入MyBatis的依赖。

可以在Maven仓库中找到最新的MyBatis版本，并将其添加到pom.xml文件中。

<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.6</version></dependency>第三步：创建数据源配置文件在src/main/resources目录下创建一个名为"mybatis-config.xml"的文件，并在其中配置数据源信息。

以下是一个示例配置：<?xml version="1.0" encoding="UTF-8"?><configuration><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="url"value="jdbc:mysql://localhost:3306/mybatis_demo"/><property name="username" value="root"/></dataSource></environment></environments><mappers></mappers></configuration>注意：在实际项目中，我们通常会将数据库连接信息配置在外部的配置文件中，而不是直接写在mybatis-config.xml文件中。

详解Mybatis通用Mapper介绍与使用

详解Mybatis通⽤Mapper介绍与使⽤使⽤Mybatis的开发者，⼤多数都会遇到⼀个问题，就是要写⼤量的SQL在xml⽂件中，除了特殊的业务逻辑SQL之外，还有⼤量结构类似的增删改查SQL。

⽽且，当数据库表结构改动时，对应的所有SQL以及实体类都需要更改。

这⼯作量和效率的影响或许就是区别增删改查程序员和真正程序员的屏障。

这时，通⽤Mapper便应运⽽⽣……什么是通⽤Mapper通⽤Mapper就是为了解决单表增删改查，基于Mybatis的插件。

开发⼈员不需要编写SQL，不需要在DAO中增加⽅法，只要写好实体类，就能⽀持相应的增删改查⽅法。

如何使⽤以MySQL为例，假设存在这样⼀张表：CREATE TABLE `test_table` (`id` bigint(20) NOT NULL AUTO_INCREMENT,`name` varchar(255) DEFAULT '',`create_time` datetime DEFAULT NULL,`create_user_id` varchar(32) DEFAULT NULL,`update_time` datetime DEFAULT NULL,`update_user_id` varchar(32) DEFAULT NULL,`is_delete` int(8) DEFAULT NULL,PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;主键是 id ，⾃增。

下⾯以这张表为例介绍如何使⽤通⽤Mapper。

Maven依赖<dependency><groupId>tk.mybatis</groupId><artifactId>mapper</artifactId><version>3.3.9</version></dependency>SpringMVC配置<beanclass="tk.mybatis.spring.mapper.MapperScannerConfigurer"><propertyname="basePackage"value=".bluemoon.bd.service.spider.dao"/><propertyname="properties"><value>mappers=mon.Mapper</value></property></bean>注意这⾥使⽤ tk.mybatis.spring.mapper.MapperScannerConfigure 替换原来Mybatis的org.mybatis.spring.mapper.MapperScannerConfigurer 。

MyBatis核心技术全解与项目实战读书笔记

《MyBatis核心技术全解与项目实战》读书笔记1. 第一章 MyBatis简介本章主要介绍了MyBatis的基本概念、特点和优势，以及其在Java企业级应用开发中的重要作用。

MyBatis是一个优秀的持久层框架，它将SQL语句与Java对象映射(POJO)相结合，使得开发人员可以更加方便地操作数据库。

MyBatis的主要目标是简化数据库操作，提高开发效率，同时也提供了良好的数据封装和安全性。

SqlSessionFactory:用于创建SqlSession对象，SqlSession是MyBatis中执行SQL语句的核心接口。

SqlSession:用于执行SQL语句的会话对象，可以通过它来执行增删改查等操作。

Mapper:映射器接口，用于定义SQL语句和Java对象之间的映射关系。

Configuration:MyBatis的全局配置类，用于配置各种属性，如缓存策略、事务管理等。

插件：MyBatis的插件机制，允许开发者自定义拦截器、类型处理器等组件，以实现对MyBatis的功能扩展。

灵活性：MyBatis支持多种存储结构，如JDBC、ODBC、JNDI等，同时还支持自定义类型处理器和插件，使得MyBatis能够满足各种复杂的数据库操作需求。

易用性：MyBatis提供了简洁的XML映射文件来描述SQL语句和Java对象之间的映射关系，使得开发者无需编写复杂的SQL语句即可完成数据库操作。

性能优化：MyBatis通过一级缓存和二级缓存机制来提高查询性能，同时还支持动态SQL、分页查询等功能，使得MyBatis能够在高并发环境下保持良好的性能表现。

安全性：MyBatis提供了严格的权限控制机制，可以限制不同用户对数据库的操作权限，保证数据的安全性。

1.1 MyBatis概念及特点MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。

相比于传统的数据访问技术，MyBatis让开发者能够更加直接地与数据库交互，从而有效地避免了大量繁琐的SQL语句编写工作。

黑马程序员mybatis教程第一天：原始dao开发方法(2)

mapper代理方法（程序员只需要mapper接口（相当于dao接口））思路（mapper代理开发规范）程序员还需要编写mapper.xml映射文件程序员编写mapper接口需要遵循一些开发规范，mybatis可以自动生成mapper接口实现类代理对象。

开发规范：1、在mapper.xml中namespace等于mapper接口地址2、mapper.java接口中的方法名和mapper.xml中statement的id一致3、mapper.java接口中的方法输入参数类型和mapper.xml中statement的parameterType指定的类型一致。

4、mapper.java接口中的方法返回值类型和mapper.xml中statement的resultType指定的类型一致。

总结：以上开发规范主要是对下边的代码进行统一生成：User user = sqlSession.selectOne("test.findUserById", id); sqlSession.insert("test.insertUser", user);。

mapper.javamapper.xml在SqlMapConfig.xml中加载mapper.xml测试一些问题总结代理对象内部调用selectOne或selectList如果mapper方法返回单个pojo对象（非集合对象），代理对象内部通过selectOne 查询数据库。

如果mapper方法返回集合对象，代理对象内部通过selectList查询数据库。

mapper接口方法参数只能有一个是否影响系统开发mapper接口方法参数只能有一个，系统是否不利于扩展维护。

系统框架中，dao层的代码是被业务层公用的。

即使mapper接口只有一个参数，可以使用包装类型的pojo满足不同的业务方法的需求。

注意：持久层方法的参数可以包装类型、map。

详细讲解mybatis的执行流程

详细讲解mybatis的执⾏流程MyBatis 可能很多⼈都⼀直在⽤，但是 MyBatis 的 SQL 执⾏流程可能并不是所有⼈都清楚了，那么既然进来了，通读本⽂你将收获如下：1、Mapper 接⼝和映射⽂件是如何进⾏绑定的2、MyBatis 中 SQL 语句的执⾏流程3、⾃定义 MyBatis 中的参数设置处理器 typeHandler4、⾃定义 MyBatis 中结果集处理器 typeHandlerPS：本⽂基于 MyBatis3.5.5 版本源码概要在 MyBatis 中，利⽤编程式进⾏数据查询，主要就是下⾯⼏⾏代码：SqlSession session = sqlSessionFactory.openSession();UserMapper userMapper = session.getMapper(UserMapper.class);List<LwUser> userList = userMapper.listUserByUserName("孤狼1号");复制代码第⼀⾏是获取⼀个 SqlSession 对象，第⼆⾏就是获取 UserMapper 接⼝，第三⾏⼀⾏代码就实现了整个查询语句的流程，接下来我们就来仔细分析⼀下第⼆和第三步。

获取 Mapper 接⼝(getMapper)第⼆步是通过 SqlSession 对象是获取⼀个 Mapper 接⼝，这个流程还是相对简单的，下⾯就是我们调⽤ session.getMapper ⽅法之后的运⾏时序图：1、在调⽤ getMapper 之后，会去 Configuration 对象中获取 Mapper 对象，因为在项⽬启动的时候就会把 Mapper 接⼝加载并解析存储到 Configuration 对象2、通过 Configuration 对象中的 MapperRegistry 对象属性，继续调⽤ getMapper ⽅法3、根据 type 类型，从 MapperRegistry 对象中的 knownMappers 获取到当前类型对应的代理⼯⼚类，然后通过代理⼯⼚类⽣成对应 Mapper 的代理类4、最终获取到我们接⼝对应的代理类 MapperProxy 对象⽽ MapperProxy 可以看到实现了 InvocationHandler，使⽤的就是 JDK 动态代理。

黑马程序员：Mybatis笔记第一天

黑马程序员：Mybatis笔记第一天第1章课程计划第一天：1、mybatis的介绍2、Mybatis的入门a)使用jdbc操作数据库存在的问题b)Mybatis的架构c)Mybatis的入门程序3、Dao的开发方法a)原始dao的开发方法b)动态代理方式4、SqlMapConfig.xml文件说明第二天：1、输入映射和输出映射a)输入参数映射b)返回值映射2、动态sql3、关联查询a)一对一关联b)一对多关联4、Mybatis整合spring第2章MyBatis介绍MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。

2013年11月迁移到Github。

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

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

第3章使用jdbc编程问题总结3.1创建mysql数据库先导入创建数据库的sql脚本导入到数据库中。

3.2创建工程开发环境：eclipse marsJdk：1.71、创建一个java工程。

2、导入jar包。

此时需要mysql 的数据库驱动。

3.3jdbc编程步骤：1、加载数据库驱动2、创建并获取数据库链接3、创建jdbc statement对象4、设置sql语句5、设置sql语句中的参数(使用preparedStatement)6、通过statement执行sql并获取结果7、对sql执行结果进行解析处理8、释放资源(resultSet、preparedstatement、connection)3.4jdbc程序public static void main(String[] args) {Connection connection = null;PreparedStatement preparedStatement = null;ResultSet resultSet = null;try {//加载数据库驱动Class.forName("com.mysql.jdbc.Driver");//通过驱动管理类获取数据库链接connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEnc oding=utf-8", "root", "root");//定义sql语句?表示占位符String sql = "select * from user where username = ?";//获取预处理statementpreparedStatement = connection.prepareStatement(sql);//设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值preparedStatement.setString(1, "王五");//向数据库发出sql执行查询，查询出结果集resultSet = preparedStatement.executeQuery();//遍历查询结果集while(resultSet.next()){System.out.println(resultSet.getString("id")+""+resultSet.getString("username"));}} catch (Exception e) {e.printStackTrace();}finally{//释放资源if(resultSet!=null){try {resultSet.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(preparedStatement!=null){try {preparedStatement.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}if(connection!=null){try {connection.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}上边使用jdbc的原始方法（未经封装）实现了查询数据库表记录的操作。

Mybatismapper动态代理的原理详解

Mybatismapper动态代理的原理详解在开始动态代理的原理讲解以前，我们先看⼀下集成mybatis以后dao层不使⽤动态代理以及使⽤动态代理的两种实现⽅式，通过对⽐我们⾃⼰实现dao层接⼝以及mybatis动态代理可以更加直观的展现出mybatis动态代理替我们所做的⼯作，有利于我们理解动态代理的过程，讲解完以后我们再进⾏动态代理的原理解析，此讲解基于mybatis的环境已经搭建完成，并且已经实现了基本的⽤户类编写以及⽤户类的Dao接⼝的声明，下⾯是Dao层的接⼝代码1public interface UserDao {2/*3查询所有⽤户信息4*/5 List<User> findAll();67/**8 * 保存⽤户9 * @param user10*/11void save(User user);1213/**14 * 更新⽤户15 * @return16*/17void update(User user);18/**19 * 删除⽤户20*/21void delete(Integer userId);2223/**24 * 查找⼀个⽤户25 * @param userId26 * @return27*/28 User findOne(Integer userId);2930/**31 * 根据名字模糊查询32 * @param name33 * @return34*/35 List<User> findByName(String name);36/**37 * 根据组合对象进⾏模糊查询38 * @param vo39 * @return40*/41 List<User> findByQueryVo(QueryVo vo);42 }View Code⼀、Mybatis dao层两种实现⽅式的对⽐1.dao层不使⽤动态代理　dao层不使⽤动态代理的话，就需要我们⾃⼰实现dao层的接⼝，为了简便起见，我只是实现了Dao接⼝中的findAll⽅法，以此⽅法为例⼦来展现我们⾃⼰实现Dao的⽅式的情况，让我们来看代码：1public class UserDaoImpl implements UserDao{2private SqlSessionFactory factory;3public UserDaoImpl(SqlSessionFactory factory){4this.factory = factory;5 }6public List<User> findAll() {7//1.获取sqlSession对象8 SqlSession sqlSession = factory.openSession();9//2.调⽤selectList⽅法10 List<User> list = sqlSession.selectList("erDao.findAll");11//3.关闭流12 sqlSession.close();13return list;14 }1516public void save(User user) {1920public void update(User user) {2122 }2324public void delete(Integer userId) {2526 }2728public User findOne(Integer userId) {29return null;30 }3132public List<User> findByName(String name) {33return null;34 }3536public List<User> findByQueryVo(QueryVo vo) {37return null;38 }View Code这⾥的关键代码 List<User> list = sqlSession.selectList("erDao.findAll")，需要我们⾃⼰⼿动调⽤SqlSession⾥⾯的⽅法，基于动态代理的⽅式最后的⽬标也是成功的调⽤到这⾥。

详解MyBatis开发Dao层的两种方式（Mapper动态代理方式）

详解MyBatis开发Dao层的两种⽅式（Mapper动态代理⽅式）MyBatis开发原始Dao层请阅读我的上⼀篇博客：接上⼀篇博客继续介绍MyBatis开发Dao层的第⼆种⽅式：Mapper动态代理⽅式Mapper接⼝开发⽅法只需要程序员编写Mapper接⼝（相当于Dao接⼝），由Mybatis框架根据接⼝定义创建接⼝的动态代理对象，代理对象的⽅法体同上⼀篇博客中Dao接⼝实现类⽅法。

Mapper接⼝开发需要遵循以下规范：（1）Mapper.xml⽂件中的namespace与mapper接⼝的类路径相同。

（2）Mapper接⼝⽅法名和Mapper.xml中定义的每个statement的id相同（3）Mapper接⼝⽅法的输⼊参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同（4）Mapper接⼝⽅法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同1、定义mapper映射⽂件UserMapper.xml（内容同User.xml），需要修改namespace的值为 UserMapper接⼝路径。

将UserMapper.xml放在classpath 下sqlmapperr⽬录下。

<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Mapper 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="erMapper"><select id="getUserById" parameterType="int" resultType="er">select * from user where id = #{id}</select><insert id="insertUser" parameterType="er"><selectKey keyProperty="id" order="AFTER" resultType="ng.Integer">select LAST_INSERT_ID()</selectKey>insert into user(username,birthday,sex,address)values(#{username},#{birthday},#{sex},#{address})</insert><update id="updateUser" parameterType="er">update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}where id=#{id}</update><delete id="deleteUserById" parameterType="int">delete from user where id=#{id}</delete></mapper>2、UserMapper.java接⼝⽂件package com.xyfer.mapper;import er;public interface UserMapper {public User getUserById(int id); //根据id值查询⼀个⽤户public void insertUser(User user); //新增⼀个⽤户public void updateUser(User user); //修改⼀个⽤户public void deleteUser(int id); //删除⼀个⽤户}接⼝定义有如下特点：（1）UserMapper接⼝⽅法名和Mapper.xml中定义的statement的id相同（2）UserMapper接⼝⽅法的输⼊参数类型和mapper.xml中定义的statement的parameterType的类型相同（3） UserMapper接⼝⽅法的输出参数类型和mapper.xml中定义的statement的resultType的类型相同3、在SqlMapConfig.xml⽂件中加载UserMapper.xml⽂件<mappers><mapper resource="UserMapper.xml"/></mappers>4、测试package com.xyfer.mapper;import static org.junit.Assert.*;import java.io.InputStream;import java.util.Date;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.Before;import org.junit.Test;import er;import junit.framework.TestCase;public class UserMapperTest extends TestCase{private SqlSessionFactory sqlSessionFactory;protected void setUp() throws Exception {SqlSessionFactoryBuilder sessionFactoryBuilder = new SqlSessionFactoryBuilder();InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");sqlSessionFactory = sessionFactoryBuilder.build(inputStream);}@Testpublic void testGetUserById() {//获取sqlsessionSqlSession sqlsession = sqlSessionFactory.openSession();//获取UserMapper接⼝代理对象UserMapper userMapper = sqlsession.getMapper(UserMapper.class);//调⽤代理对象⽅法User user = userMapper.getUserById(10);//打印结果System.out.println(user);//关闭sqlsessionsqlsession.close();}@Testpublic void testInsertUser() {//获取sqlsessionSqlSession sqlsession = sqlSessionFactory.openSession();//获取UserMapper接⼝代理对象UserMapper userMapper = sqlsession.getMapper(UserMapper.class);//新建⼀个对象User user = new User();user.setUsername("⼩谢");user.setSex("男");user.setBirthday(new Date());user.setAddress("浙江省杭州市");//调⽤代理对象⽅法userMapper.insertUser(user);//关闭sqlsessionsqlsession.close();}@Testpublic void testUpdateUser() {//获取sqlsessionSqlSession sqlsession = sqlSessionFactory.openSession();//获取UserMapper接⼝代理对象UserMapper userMapper = sqlsession.getMapper(UserMapper.class);//新建⼀个对象User user = new User();user.setUsername("⼩谢");user.setSex("男");user.setBirthday(new Date());user.setAddress("上海市");//调⽤代理对象⽅法userMapper.updateUser(user);//关闭sqlsessionsqlsession.close();}@Testpublic void testDeleteUser() {//获取sqlsessionSqlSession sqlsession = sqlSessionFactory.openSession();//获取UserMapper接⼝代理对象UserMapper userMapper = sqlsession.getMapper(UserMapper.class);//调⽤代理对象⽅法userMapper.deleteUser(6);//关闭sqlsessionsqlsession.close();}}以上步骤，完成mybatis框架以Mapper动态代理⽅式开发Dao层，并对数据库进⾏增删改查操作。

mybatis逆向工程原理

mybatis逆向工程原理MyBatis逆向工程原理一、概述MyBatis是一个开源的持久层框架，它通过XML或注解的方式，将数据库操作与Java对象的映射关系进行配置，简化了数据库操作的实现。

而MyBatis逆向工程是MyBatis框架的一个重要功能，它可以根据数据库中的表结构自动生成Java代码，大大减少了开发人员的工作量。

二、逆向工程原理MyBatis逆向工程的原理主要包括以下几个步骤：1. 数据库连接配置在逆向工程中，首先需要在MyBatis的配置文件中配置数据库的连接信息，包括数据库的驱动、URL、用户名和密码等。

这样MyBatis才能够连接数据库并获取表结构信息。

2. 数据库表结构解析MyBatis逆向工程需要解析数据库中的表结构信息，包括表名、字段名、字段类型、主键等。

它通过获取数据库的元数据，即DatabaseMetaData，来获取表的相关信息。

3. 代码生成在获取了表结构信息之后，MyBatis逆向工程会根据配置文件中的模板，生成相应的Java代码。

模板中包括了Java类的包名、类名、字段名、字段类型等信息，以及对应的get和set方法等。

生成的Java代码可以直接用于数据库的CRUD操作。

4. 配置文件生成除了生成Java代码，MyBatis逆向工程还会生成相应的配置文件，包括映射文件和配置文件。

映射文件用于配置数据库操作的SQL语句，配置文件用于配置数据源等信息。

5. 代码注释生成为了增加代码的可读性和可维护性，MyBatis逆向工程还可以根据表结构信息生成相应的代码注释。

注释内容可以包括表名、字段名、字段类型、主键等信息，以及相应的业务说明。

三、使用步骤使用MyBatis逆向工程可以按照以下步骤进行：1. 配置数据库连接信息在MyBatis的配置文件中，配置数据库的连接信息，包括数据库的驱动、URL、用户名和密码等。

2. 配置逆向工程生成规则在MyBatis的配置文件中，配置逆向工程的生成规则，包括要生成的表、生成的Java类的包名、类名等。

mybatis项目开发步骤

mybatis项目开发步骤
1.确定数据结构：在开始开发之前，需要确定数据结构，包括表名、字段名称、数据类型、约束等。

2. 配置数据源：在mybatis中，需要配置数据源，即数据库连接信息。

可以通过xml或注解方式进行配置。

3. 定义实体类：定义与数据库表对应的实体类，实体类的属性名称和数据表的字段名称应该一致。

4. 定义Mapper接口：定义Mapper接口，包含对数据库的增删改查操作。

可以通过xml或注解方式进行定义。

5. 定义Mapper.xml文件：如果使用xml方式定义Mapper接口，需要创建Mapper.xml文件，并在文件中定义sql语句。

6. 编写测试类：编写测试类，调用Mapper接口中定义的方法，进行数据操作。

7. 配置日志：配置日志，方便开发和运维人员进行问题排查和系统优化。

8. 部署和测试：部署到服务器上进行测试，确保系统稳定和正常运行。

以上就是mybatis项目开发的基本步骤，开发人员可以根据需要进行调整和优化。

- 1 -。

mybatis逆向工程使用步骤详解

mybatis逆向⼯程使⽤步骤详解使⽤mybatis⽣成逆向⼯程的详细步骤，我个⼈感觉这个是最简单的⼀个了，虽然⽹上有很多种的⽅法来⽣成逆向⼯程，可是这个⽅法最简单。

在这⾥我是使⽤maven搭建的环境，但是在正常的环境下也是⼀样的。

步骤：1、创建⼀个genreatorConfig.xml⽂件，这个⽂件的名字可以任意。

我创建的时候是将它放在了src/main/resources下，这个⽂件的内容并不需要去记，只需要去⽹上找就可以了。

我们要做的只是对配置⽂件当中的⼀些部分做修改，修改成⾃⼰的数据就可以了。

1 <?xml version="1.0" encoding="UTF-8"?>2 <!DOCTYPE generatorConfiguration3 PUBLIC "-////DTD MyBatis Generator Configuration 1.0//EN"4 "/dtd/mybatis-generator-config_1_0.dtd">56 <generatorConfiguration>7 8 <classPathEntry location="D:\MysqlJdbcconnector/mysql-connector-java-5.1.41-bin.jar" />91011 <context id="DB2Tables" targetRuntime="MyBatis3">1213 <commentGenerator>14 <property name="suppressDate" value="true"/>15 <property name="suppressAllComments" value="true"/>16 </commentGenerator>17 18 <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost/pet_hospital" userId="root" password="112233">19 </jdbcConnection>20 <javaTypeResolver>21 <property name="forceBigDecimals" value="false"/>22 </javaTypeResolver>23 24 <javaModelGenerator targetPackage="com.qianfeng.bean" targetProject="src/main/java">25 <property name="enableSubPackages" value="true"/>26 <property name="trimStrings" value="true"/>27 </javaModelGenerator>28 29 <sqlMapGenerator targetPackage="com.qianfeng.bean" targetProject="src/main/java">30 <property name="enableSubPackages" value="true"/>31 </sqlMapGenerator>32 33 <javaClientGenerator type="XMLMAPPER" targetPackage="com.qiafeng.dao" targetProject="src/main/java">3435 <property name="enableSubPackages" value="true"/>3637 </javaClientGenerator>38 39 <table tableName="owners"40 domainObjectName="Owners"41 ></table>42 <table tableName="pets"43 domainObjectName="Pets"44 ></table>45 <table tableName="types"46 domainObjectName="Types"47 ></table>48 <table tableName="employee"49 domainObjectName="Employee"50 ></table>51 <table tableName="specialties"52 domainObjectName="Specialties"53 ></table>54 <table tableName="vets"55 domainObjectName="Vets"56 ></table>57 <table tableName="visits"58 domainObjectName="Visits"59 ></table>60 <table tableName="vet_specialties"61 domainObjectName="VetSpecialties"62 ></table>6364 </context>65 </generatorConfiguration>2、导⼊相应的jar包，mybatis-generator-core这个包和mysql-connector-java这个包3、创建⼀个测试类，然后运⾏下⾯代码就可以了。

SpringBoot整合MyBatis逆向工程及MyBatis通用Mapper实例详解

SpringBoot整合MyBatis逆向⼯程及MyBatis通⽤Mapper实例详解⼀、添加所需依赖，当前完整的pom⽂件如下：<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>1.5.6.RELEASE</version></parent><groupId>org.rcddup</groupId><artifactId>rcddup-custom</artifactId><version>1.0.0</version><properties><java.version>1.8</java.version><mybatis.version>1.3.1</mybatis.version><mapper.version>3.4.3</mapper.version><mybatis-generator.version>1.3.3</mybatis-generator.version><mybatis-tk.version>1.1.4</mybatis-tk.version><pagehelper.version>1.2.1</pagehelper.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>${mybatis.version}</version></dependency><dependency><groupId>org.mybatis.generator</groupId><artifactId>mybatis-generator-core</artifactId><version>${mybatis-generator.version}</version></dependency><dependency><groupId>tk.mybatis</groupId><artifactId>mapper-spring-boot-starter</artifactId><version>${mybatis-tk.version}</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency></dependencies><build><plugins><plugin><groupId>org.mybatis.generator</groupId><artifactId>mybatis-generator-maven-plugin</artifactId><version>${mybatis.generator.version}</version><dependencies><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>${mysql.version}</version></dependency><dependency><groupId>tk.mybatis</groupId><artifactId>mapper</artifactId><version>${mapper.version}</version></dependency></dependencies><configuration><verbose>true</verbose><overwrite>true</overwrite><configurationFile>${basedir}/src/main/resources/generator/generatorConfig.xml</configurationFile></configuration></plugin></plugins></build></project> MyBtais 结合通⽤ Mapper ⾮常好使，接下来看逆向⼯程的配置。

mybatis逆向工程生成的mapper方法使用（有例子）

mybatis逆向⼯程⽣成的mapper⽅法使⽤（有例⼦）在上⼀篇⽂章中介绍了如何在IDEA+springboot下搭建mybatis逆向⼯程以及⼀个简单的接⼝。

本⽂主要总结⼀下mapper接⼝中⽅法的使⽤，和个⼈的⼀些理解。

mapper接⼝中的函数及⽅法mybatis的逆向⼯程中会⽣成实例及实例对应的example，example⽤于添加条件，相当where后⾯的部分xxxExample example = new xxxExample();Criteria criteria = new Example().createCriteria();创建单元测试类，在springboot中⼗分⽅便先注⼊userMapper,然后再测试⽅法不要忘了在UserMapper接⼝上加上@Mapper注解，不然会报错package com.example.dao;import erMapper;import org.junit.jupiter.api.Test;import org.springframework.boot.test.context.SpringBootTest; import javax.annotation.Resource;@SpringBootTestpublic class UserDaoTest {@Testpublic void index(){System.out.println("我是SpringBoot的单元测试");}@Resourceprivate UserMapper userMapper;/*** 根据主键查找*/@Testvoid selectByPrimaryKey() {System.out.println(userMapper.selectByPrimaryKey(1)); }}/*** 根据条件查询*/@Testvoid selectByExample(){//通过criteria构造查询条件UserExample userExample = new UserExample();// userExample.setOrderByClause("username asc"); //asc升序,desc降序排列// userExample.setDistinct(false); //去除重复,true是选择不重复记录,false反之UserExample.Criteria criteria = userExample.createCriteria(); //构造⾃定义查询条件 criteria.andUsernameEqualTo("admin");criteria.andPasswordEqualTo("admin");//⾃定义查询条件可能返回多条记录,使⽤List接收List<User> users = userMapper.selectByExample(userExample);System.out.println(users);}/*** 插⼊*/@Testvoid insert(){User user = new User();// user.setId(null);user.setUsername("张三");// user.setPassword();System.out.println(userMapper.insert(user));}@Testvoid insertSelective(){User user = new User();user.setUsername("zhangsan");System.out.println(userMapper.insertSelective(user));}@Testvoid deleteByPrimaryKey(){System.out.println(userMapper.deleteByPrimaryKey(2));}@Testvoid deleteByExample(){//通过criteria构造查询条件UserExample userExample = new UserExample();// userExample.setOrderByClause("username asc"); //asc升序,desc降序排列// userExample.setDistinct(false); //去除重复,true是选择不重复记录,false反之UserExample.Criteria criteria = userExample.createCriteria(); //构造⾃定义查询条件 criteria.andIdBetween(5,13);//⾃定义查询条件可能返回多条记录,使⽤List接收userMapper.deleteByExample(userExample);System.out.println();}@Testvoid updateByPrimaryKey(){User user = new User();user.setId(4);// user.setUsername("lisi");userMapper.updateByPrimaryKey(user);}@Testvoid updateByPrimaryKeySelective(){User user = new User();user.setId(4);user.setUsername("lisi");userMapper.updateByPrimaryKeySelective(user);}@Testvoid updateByExample(){//通过criteria构造查询条件UserExample userExample = new UserExample();// userExample.setOrderByClause("username asc"); //asc升序,desc降序排列// userExample.setDistinct(false); //去除重复,true是选择不重复记录,false反之UserExample.Criteria criteria = userExample.createCriteria(); //构造⾃定义查询条件criteria.andIdEqualTo(3);User user = new User();user.setId(3);user.setUsername("李四2");// user.setPassword("123456");userMapper.updateByExample(user,userExample);}@Testvoid updateByExampleSelective(){//通过criteria构造查询条件UserExample userExample = new UserExample();// userExample.setOrderByClause("username asc"); //asc升序,desc降序排列// userExample.setDistinct(false); //去除重复,true是选择不重复记录,false反之UserExample.Criteria criteria = userExample.createCriteria(); //构造⾃定义查询条件criteria.andPasswordEqualTo("123456");User user = new User();user.setUsername("李四");// user.setPassword("123456");userMapper.updateByExampleSelective(user,userExample);}相当于WHERE，将⼀些限制条件拼接到SQL语句后⾯，具体的参照上⾯所说。

MybatisGenerator逆向工程的使用详细教程

MybatisGenerator逆向⼯程的使⽤详细教程⼀、MyBatis Generator简介MyBatis Generator（MBG）是MyBatis和iBATIS的代码⽣成器。

它将为所有版本的MyBatis以及版本2.2.0之后的iBATIS版本⽣成代码。

它将审查数据库表（或许多表），并将⽣成可⽤于访问表的构件。

这减少了设置对象和配置⽂件以与数据库表交互的初始⿇烦。

MBG寻求对简单CRUD（创建，检索，更新，删除）的⼤部分数据库操作产⽣重⼤影响。

您仍然需要为连接查询或存储过程⼿动编写SQL和对象代码。

MyBatis Generator将⽣成：与表结构匹配的Java POJO。

这可能包括：⼀个匹配表的主键的类（如果有主键）⼀个匹配表的⾮主键字段的类（BLOB字段除外）包含表的BLOB字段的类（如果表具有BLOB字段）⽤于启⽤动态选择，更新和删除的类这些类之间存在适当的继承关系。

请注意，⽣成器可以配置为⽣成不同类型的POJO层次结构 - 例如，如果您愿意，可以选择为每个表⽣成单个域对象。

MyBatis/iBATIS兼容的SQL Map XML⽂件。

MBG为配置中的每个表上的简单CRUD函数⽣成SQL。

⽣成的SQL语句包括：insert 插⼊update by primary key 按主键更新update by example (using a dynamic where clause) 通过条件更新（使⽤动态where⼦句）delete by primary key 按主键删除delete by example (using a dynamic where clause) 按条件删除（使⽤动态where⼦句）select by primary key 按主键查询select by example (using a dynamic where clause) 按条件查询（使⽤动态where⼦句）count by example 按条件查询记录总数根据表结构的不同，这些语句有不同的变体（例如，如果表没有主键，则MBG不会通过主键功能⽣成更新）。

Mybatis的逆向工程以及Example的实例函数及详解

Mybatis的逆向⼯程以及Example的实例函数及详解Mybatis-generator是Mybatis的逆向⼯程（根据数据库中的表⽣成java代码）
Mybatis的逆向⼯程会⽣成实例及实例对应的example，example⽤于添加条件，相当于where后⾯的条件部分。

example类中有两种创建criteria对象的⽅法：createcriteria or
区别：⽣成or字句
⽤了逆向⼯程就会⾃动⽣成xml⽂件，不⽤再⾃⼰写增删改查语句了（xml都⾃动⽣成了相应sql语句）
链接：https:///biandous/article/details/65630783
对于添加条件就⽤example添加条件就⾏！（在example类中有各种⽅法可以调⽤）
逆向⼯程的配置⽂件主要做的⼏件事是：
1. 连接数据库，这是必须的，要不然怎么根据数据库的表⽣成代码呢？
2. 指定要⽣成代码的位置，要⽣成的代码包括pojo类，mapper.xml和mapper.java
3. 指定数据库中想要⽣成哪些表。

解析MyBatis中Mapper生效的来龙去脉

解析MyBatis中Mapper⽣效的来龙去脉⽬录⼀、MyBatis基本使⽤1.1 编写配置⽂件1.2 编写Mapper接⼝及测试⽅法1.3 结果⼆、源码分析2.1 通过配置⽂件构建出 SqlSessionFactory2.2 获取 SqlSession 对象2.3 根据 SqlSession 获取 Mapper 代理2.4 通过 Mapper 代理，执⾏⽅法操作数据库2.5 整体流程图最近闲了快有半个多⽉了，⼀直提不起兴致再去看⼀些书籍（没有以前疯狂吸⾷知识的欲望了）。

不过这⼀两天不知道是什么筋搭错了⾮常想写点什么，但⼜不知道写点啥（苦恼）。

所以我就结合了⼀下本⼈⼯作中经常⽤到但没有深⼊的技术下⼿了，最后思来想去就选择了 MyBatis 中 Mapper ⽂件这⼀块的知识内容⼊⼿了。

以前只是知道写⼀个 Mapper 接⼝，对应着再去写⼀个 Mapper.xml ⽂件然后将 Mapper 接⼝位置和 Mapper.xml ⽂件位置通过 MyBatisConfig.xml 的配置⽂件关联起来就可以⾮常⽅便的操作访问数据库，但究其原因确是说不上个所以然来（汗颜）。

那既然搞出了前因，后⾯就⼀起往下学咯！⼀、MyBatis基本使⽤⼀切都从最简单的开始，所以先来回顾⼀下其基本的使⽤（不会吧不会吧，最基本的hello world别忘了）。

步骤：1、⾸先我们要创建⼀个maven⼯程2、添加MyBatis的依赖及MySQL依赖，如下：<dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.6</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.49</version></dependency>3、再添加⼀个测试单元依赖吧，等会要通过测试单元进⾏测试<dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency>OK，到这⼀步项⽬的基本环境就搭建完毕了，下⾯就是正式的使⽤ MyBatis 框架相关的内容了。

mybatis工作原理流程

mybatis工作原理流程
MyBatis是一种基于Java的持久化框架，它通过XML或注解的
方式将Java对象映射到数据库中的数据。

MyBatis的工作原理可以简单地概括为以下流程：
1. 配置文件加载
MyBatis的配置文件包含数据源配置、映射文件配置、缓存配置等内容，它通过解析配置文件来获取相关配置信息。

2. SqlSessionFactory创建
SqlSessionFactory是MyBatis的核心接口，它负责创建SqlSession对象，SqlSession对象是与数据库交互的主要接口。

3. SqlSession创建
SqlSession是MyBatis与数据库交互的主要接口，它提供了各
种操作数据库的方法，如插入、更新、删除和查询等。

4. Mapper接口调用
Mapper接口是MyBatis中定义操作数据库的接口，它通过动态
代理方式生成接口的实现类，并调用相应的SQL语句完成数据库操作。

5. SQL语句执行
MyBatis通过动态生成SQL语句，将Java对象与数据库中的数
据进行映射。

在执行SQL语句前，MyBatis会将SQL语句进行预编译，提高SQL语句的执行效率。

6. 数据库操作结果返回
MyBatis通过执行SQL语句，将数据库操作结果返回给Java程
序，Java程序可以根据返回结果进行相应的处理。

以上就是MyBatis的工作原理流程，通过理解MyBatis的工作原理，我们可以更好地使用MyBatis框架进行Java开发。

mybatis实现mapper代理模式的方式

mybatis实现mapper代理模式的⽅式今晚继续复习mybtis以根据id值查询单条数据为例编写SqlMapConfig.xml⽂件<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://localhost:3306/db_shop? useUnicode=true&characterEncoding=utf-8"/><property name="username" value="root"/> <property name="password" value=""/></dataSource></environment></environments><mappers><mapper resource="product.xml"/></mappers></configuration>编写失⾎模型对象：Product,最好字段名和数据库⾥⾯的字段名⼀直/**** <p>Title: Product</p> *<p>Description: 商品类失⾎模型</p> *@author Alon *@date 2020年9⽉27⽇下午6:51:57* @version 1.0 */public class Product {private int p_id;private String name;private int p_number;private double price;private String add_time;public Product(int p_id, String name, int p_number, double price, String add_time) {super();this.p_id = p_id; = name;this.p_number = p_number;this.price = price;this.add_time = add_time;}public Product() {super();}public int getP_id() {return p_id; }public void setP_id(int p_id) {this.p_id = p_id; }public String getName() { return name; }public void setName(String name) { = name; }public int getP_number() {return p_number; }public void setP_number(int p_number) { this.p_number = p_number; }public double getPrice() { return price; }public void setPrice(double price) { this.price = price; }public String getAdd_time() { return add_time;}public void setAdd_time(String add_time) { this.add_time = add_time; }@Overridepublic String toString() {return "Product [p_id=" + p_id + ", name=" + name + ", p_number=" + p_number + ", price=" + price + ", add_time=" + add_time + "]"; } }编写单个映射关系的sql.xml：product.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper PUBLIC "-////DTD Mapper 3.0//EN" "/dtd/mybatis-3-mapper.dtd"><!-- 映射的sql⽂件 namespace:命名空间，可以理解成将部分的sql语句进⾏隔离。

mybatis工作原理及流程

mybatis工作原理及流程Mybatis工作原理及流程。

Mybatis是一款非常流行的持久层框架，它可以帮助我们简化数据库操作，并且提供了强大的映射和查询功能。

在本文中，我们将深入探讨Mybatis的工作原理及流程。

Mybatis的工作原理可以简单地分为两个部分，SQL映射和SQL执行。

首先，让我们来看看Mybatis是如何进行SQL映射的。

在Mybatis中，我们可以使用XML或注解来进行SQL映射。

XML方式是最常用的方式，我们可以在XML文件中编写SQL语句，并且定义参数和返回结果的映射关系。

当我们需要执行SQL时，Mybatis会根据XML文件中的配置来生成对应的SQL语句，并将参数传入SQL中进行执行。

这样，我们就可以实现Java对象和数据库表之间的映射关系，使得操作数据库变得更加方便和灵活。

接下来，让我们来看看Mybatis是如何执行SQL语句的。

当我们需要执行SQL语句时，我们可以通过SqlSession来获取对应的Mapper 接口，然后调用Mapper接口中的方法来执行SQL。

Mybatis会将方法名和方法参数与XML文件中的配置进行匹配，然后生成对应的SQL语句并执行。

执行完毕后，Mybatis会将结果映射成我们所需要的Java对象，并返回给调用方。

总的来说，Mybatis的工作流程可以简单概括为，首先，我们需要编写SQL映射文件或注解来定义SQL语句和参数映射关系；然后，我们通过SqlSession来获取Mapper接口，并调用Mapper接口中的方法来执行SQL；最后，Mybatis会将执行结果映射成Java对象并返回给调用方。

除了上述的工作流程，Mybatis还提供了许多高级特性，比如动态SQL、缓存机制、插件扩展等，这些特性都可以帮助我们更好地操作数据库并提高系统性能。

在实际项目中，Mybatis已经被广泛应用，它的简单易用和强大的功能使得它成为了Java开发中不可或缺的一部分。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

mapper代理开发
mapper.xml和mapper.java
通过MapperFactoryBean创建代理对象
此方法问题：
需要针对每个mapper进行配置，麻烦。

通过MapperScannerConfigurer进行mapper扫描（建议使用）
测试代码
逆向工程
什么是逆向工程
mybaits需要程序员自己编写sql语句，mybatis官方提供逆向工程可以针对单表自动生成mybatis执行所需要的代码（mapper.java,mapper.xml、po..）
企业实际开发中，常用的逆向工程方式：
由于数据库的表生成java代码。

下载逆向工程
使用方法（会用）
运行逆向工程
建议使用java程序方式，不依赖开发工具。

生成代码配置文件
<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC"-////DTD MyBatis Generator Configuration
1.0//EN"
"/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<context id="testTables"targetRuntime="MyBatis3">
<commentGenerator>

<property name="suppressAllComments"value="true"/> </commentGenerator>

<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mybatis"userId=" root"
password="mysql">
</jdbcConnection>

 <javaTypeResolver>
<property name="forceBigDecimals"value="false"/> </javaTypeResolver>

<javaModelGenerator targetPackage="cn.itcast.ssm.po"
targetProject=".\src">

<property name="enableSubPackages"value="false"/>

<property name="trimStrings"value="true"/>
</javaModelGenerator>

<sqlMapGenerator targetPackage="cn.itcast.ssm.mapper"
targetProject=".\src">

<property name="enableSubPackages"value="false"/> </sqlMapGenerator>

<javaClientGenerator type="XMLMAPPER"
targetPackage="cn.itcast.ssm.mapper"
targetProject=".\src">

<property name="enableSubPackages"value="false"/> </javaClientGenerator>

<table tableName="items"></table>
<table tableName="orders"></table>
<table tableName="orderdetail"></table>
<table tableName="user"></table>
</context>
</generatorConfiguration>
执行生成程序
生成后的代码：
使用生成的代码
需要将生成工程中所生成的代码拷贝到自己的工程中。

测试ItemsMapper中的方法
//自定义条件查询
@Test
publicvoid testSelectByExample() {
ItemsExample itemsExample = new ItemsExample();
//通过criteria构造查询条件
ItemsExample.Criteria criteria =
itemsExample.createCriteria();
criteria.andNameEqualTo("笔记本3");
//可能返回多条记录
List<Items> list =
itemsMapper.selectByExample(itemsExample);
System.out.println(list);
}
//根据主键查询
@Test
publicvoid testSelectByPrimaryKey() {
Items items = itemsMapper.selectByPrimaryKey(1);
System.out.println(items);
}
//插入
@Test
publicvoid testInsert() {
//构造 items对象
Items items = new Items();
items.setName("手机");
items.setPrice(999f);
itemsMapper.insert(items);
}
//更新数据
@Test
publicvoid testUpdateByPrimaryKey() {
//对所有字段进行更新，需要先查询出来再更新
Items items = itemsMapper.selectByPrimaryKey(1);
items.setName("水杯");
itemsMapper.updateByPrimaryKey(items);
//如果传入字段不空为才更新，在批量更新中使用此方法，不需要先查
询再更新
//itemsMapper.updateByPrimaryKeySelective(record);
}。