MyBatis的逆向工程

Posted 2023-04-02 poixao

MyBatis的逆向工程

• 创建逆向工程的步骤
• • 添加依赖和插件
  • 创建MyBatis的核心配置文件
  • 创建逆向工程的配置文件
  • 执行MBG插件的generate目标
• QBC
• • MyBatis3自动生成的方法
  • 使用条件进行操作
  • 根据条件查询
  • 查询所有
  • 选择性修改与其他修改

 
 

 
 

• 正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的
• 逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：
• Java实体类
  • Mapper接口
  • Mapper映射文件

创建逆向工程的步骤

添加依赖和插件

<dependencies>
    <!-- MyBatis核心依赖包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.9</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    <!-- mysql驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.27</version>
    </dependency>
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>
<!-- 控制Maven在构建过程中相关配置 -->
<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>
                <!-- 数据库连接池 -->
                <dependency>
                    <groupId>com.mchange</groupId>
                    <artifactId>c3p0</artifactId>
                    <version>0.9.2</version>
                </dependency>
                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>8.0.27</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

创建MyBatis的核心配置文件

mybatis-config

<?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="jdbc.properties"></properties>

    <typeAliases>
        <package name="com.study.mybatis.pojo"/>
    </typeAliases>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>
        <package name="com.study.mybatis.mapper"/>
    </mappers>
</configuration>

创建逆向工程的配置文件

• 文件名必须是：generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
    targetRuntime: 执行生成的逆向工程的版本
    MyBatis3Simple: 生成基本的CRUD（清新简洁版）
    MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis"
                        userId="root"
                        password="123456">
        </jdbcConnection>
        <!-- javaBean的生成策略-->
        <!--生成到 targetProject 下的 targetPackage目录下-->
        <javaModelGenerator targetPackage="com.study.mybatis.pojo" targetProject=".\\src\\main\\java">
            <!--开启使用子包,如果不开启targetPackage属性就会为包的名字-->
            <property name="enableSubPackages" value="true" />
            <!--去掉字段前后的空格-->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- SQL映射文件的生成策略 -->
        <!--SQL映射文件在 targetProject下的targetPackage目录下-->
        <sqlMapGenerator targetPackage="com.study.mybatis.mapper"
                         targetProject=".\\src\\main\\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>
        <!-- Mapper接口的生成策略 -->
        <!--注意：这里的targetPackage属性要与SQL映射文件生成策略要相同-->
        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="com.study.mybatis.mapper" targetProject=".\\src\\main\\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>
        <!-- 逆向分析的表 -->
        <!-- tableName设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName属性指定生成出来的实体类的类名 -->
        <!--
            tableName：为表名
            domainObjectName：为实体类的名
        -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

 

执行MBG插件的generate目标

执行结果
目录都会自动生成，mapper中有基本的增删改查功能

 
 

QBC

generatorConfig.xml

<context id="DB2Tables" targetRuntime="MyBatis3">

 

MyBatis3自动生成的方法

注意事项：

1. 带Example 都是根据条件进行操作
2. 带Selective 都是选择性进行操作
3. 选择性插入与其他插入的区别在于
   • 其他插入如果插入值为null,那么会将字段的值设置为null
   • 选择性插入如果插入值为null,那么就不会为字段的值赋值
4. 选择性更新和其他更新的区别
   • 其他更新如果更新值为null,那么会将字段的值设置为null
   • 选择性更新更新如果更新值为null,那么就不会为字段的值赋值

 
EmpExample example： 条件对象
Integer eid：对应主键
Emp record：对应实体类对象

方法	作用
------------------------计数---------------------------	---------------------------------------------------
int countByExample(EmpExample example);	根据条件计数
------------------------删除---------------------------	---------------------------------------------------
int deleteByExample(EmpExample example);	根据条件删除
int deleteByPrimaryKey(Integer eid);	根据主键删除
------------------------插入---------------------------	---------------------------------------------------
int insert(Emp record);	插入
int insertSelective(Emp record);	选择性插入
------------------------查询---------------------------	---------------------------------------------------
List<Emp> selectByExample(EmpExample example);	根据条件查询
Emp selectByPrimaryKey(Integer eid);	根据主键查询
------------------------更新---------------------------	---------------------------------------------------
int updateByExampleSelective( @Param(“record”) Emp record, @Param(“example”) EmpExample example);	选择性根据条件更新
int updateByExample( @Param(“record”) Emp record, @Param(“example”) EmpExample example);	根据条件更新
int updateByPrimaryKeySelective(Emp record);	选择性根据主键更新
int updateByPrimaryKey(Emp record);	根据主键更新

使用流程：同样是通过mapper接口的.class对象得到实现类，然后调用相应的方法

 

使用条件进行操作

1. 使用实体类对应的example对象的createCriteria()方法创建条件
2. 属性条件姓名规律：and+属性名+判断操作
   • 如: andEmpNameEqualTo(“张三”): 查找EmpName属性值为张三的数据
   • 多个条件为可以往后连接,都为and关系
3. 如果多个条件为 or 关系,那么使用example.or()后面跟条件即可

//创建example对象
EmpExample example = new EmpExample();
//判断条件为：empName为"张三"并且eid为空 或者 age大于20的数据
example.createCriteria().andEmpNameEqualTo("张三").andEidIsNotNull();
example.or().andAgeGreaterThan(20);
//查找此条件的数据
List<Emp> emps = mapper.selectByExample(example);

 

根据条件查询

@Test
public void testMBG() throws IOException 
    InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    //创建example对象
    EmpExample example = new EmpExample();
    /*
        1、使用example对象的createCriteria()方法创建条件
        2、属性条件姓名规律：and+属性名+判断操作
          - 如: andEmpNameEqualTo("张三"): 查找EmpName属性值为张三的数据
          - 多个条件为可以往后连接,都为and关系
        3、如果多个条件为 or 关系,那么使用example.or()后面跟条件即可
     */
    example.createCriteria().andEmpNameEqualTo("张三").andEidIsNotNull();
    example.or().andAgeGreaterThan(20);
    List<Emp> emps = mapper.selectByExample(example);
    emps.forEach(emp -> System.out.println(emp));

DEBUG 04-29 18:25:43,188 ==> Preparing: select eid, emp_name, age, sex, email, did from t_emp WHERE ( emp_name = ? and eid is not null ) or( age > ? ) (BaseJdbcLogger.java:137)

查询所有

//查询所有员工
List<Emp> emps1 = mapper.selectByExample(null);
emps1.forEach(emp -> System.out.println(emp));

 

选择性修改与其他修改

//用选择性修改 主键为1的用户
int rows = mapper.updateByPrimaryKeySelective(new Emp(1, "老七", null, null, null, null));
System.out.println("改变的行数: " + rows);

可以发现更新的值为null的字段并不会写入到数据库中

 

MyBatis学习15MyBatis的逆向工程生成代码

1. 什么是逆向工程

　　mybatis的一个主要的特点就是需要程序员自己编写sql，那么如果表太多的话，难免会很麻烦，所以mybatis官方提供了一个逆向工程，可以针对单表自动生成mybatis执行所需要的代码（包括mapper.xml、mapper.Java、po..）。一般在开发中，常用的逆向工程方式是通过数据库的表生成代码。

2. 使用逆向工程

　　使用mybatis的逆向工程，需要导入逆向工程的jar包，我用的是mybatis-generator-core-1.3.2，已经上传到下载频道了（点我下载），下面开始总结一下mybatis逆向工程的使用步骤。

2.1 新建一个工程（重要）

　　我们要新建一个java工程，这个工程专门用来使用逆向工程生成代码的。有些人可能会问，为什么要新建一个工程呢？直接在原来工程中你想生成不就可以了么？确实是这样，可以在原来的工程中生成，但是有风险，因为mybatis是根据配置文件来生成的（下面会说到），如果生成的路径中有相同的文件，那么就会覆盖原来的文件，这样会有风险。所以开发中一般都会新建一个java工程来生成，然后将生成的文件拷贝到自己的工程中，这也不麻烦，而且很安全。如下： 
 
　　从上图中看，1就是要执行的java代码，执行它即可生成我们需要的代码；2是执行过程中新建的包，这个包都可以在4的配置文件中指定，最好是跟我们自己项目的包名一致，后面就可以直接拷贝了，就不需要修改包名了；3就是jar包咯；4是配置文件。下面会详细分析。

2.1 生成代码的配置文件

　　mybatis逆向工程生成代码需要一个配置文件，名字随便起。然后mybatis会根据这个配置文件中的配置，生成相应的代码。下载好了jar包后，里面有帮助文档，打开后里面有配置文件的模板，这里就不再赘述了，下面先把配置文件写好：

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
  PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
  "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">

<generatorConfiguration>
    <context id="testTables" targetRuntime="MyBatis3">
        <commentGenerator>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="true" />
        </commentGenerator>
        <!--数据库连接的信息：驱动类、连接地址、用户名、密码 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
            connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
            password="root">
        </jdbcConnection>
        <!-- <jdbcConnection driverClass="oracle.jdbc.OracleDriver"
            connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:yycg" 
            userId="yycg"
            password="yycg">
        </jdbcConnection> -->

        <!-- 默认false，把JDBC DECIMAL 和 NUMERIC 类型解析为 Integer，为 true时把JDBC DECIMAL和NUMERIC类型解析为java.math.BigDecimal -->
        <javaTypeResolver>
            <property name="forceBigDecimals" value="false" />
        </javaTypeResolver>

        <!-- targetProject:生成PO类的位置，重要！！ -->
        <javaModelGenerator targetPackage="mybatis.po"
            targetProject=".\src">
            <!-- enableSubPackages:是否让schema作为包的后缀 -->
            <property name="enableSubPackages" value="false" />
            <!-- 从数据库返回的值被清理前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>
        <!-- targetProject:mapper映射文件生成的位置，重要！！ -->
        <sqlMapGenerator targetPackage="mybatis.mapper" 
            targetProject=".\src">
            <property name="enableSubPackages" value="false" />
        </sqlMapGenerator>
        <!-- targetPackage：mapper接口生成的位置，重要！！ -->
        <javaClientGenerator type="XMLMAPPER"
            targetPackage="mybatis.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>

 

　从上面的配置文件中可以看出，配置文件主要要做的几件事是：

1. 连接数据库，这是必须的，要不然怎么根据数据库的表生成代码呢？
2. 指定要生成代码的位置，要生成的代码包括po类， mapper.xml和mapper.java
3. 指定数据库中想要生成哪些表

2.3 执行生成程序

　　配置文件搞好了，然后就执行以下生成程序即可生成了，生成的java程序，下载的逆向工程文档中都有示例，如下：

 

public class GeneratorSqlmap {

    public void generator() throws Exception{

        List<String> warnings = new ArrayList<String>();
        boolean overwrite = true;
        //指向逆向工程配置文件
        File configFile = new File("generatorConfig.xml"); 
        ConfigurationParser cp = new ConfigurationParser(warnings);
        Configuration config = cp.parseConfiguration(configFile);
        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                callback, warnings);
        myBatisGenerator.generate(null);

    } 
    public static void main(String[] args) throws Exception {
        try {
            GeneratorSqlmap generatorSqlmap = new GeneratorSqlmap();
            generatorSqlmap.generator();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

 

运行一下即可，运行完了后刷新一下工程，就可以看到最新生成的代码了。 
 
　　这里可以看出有个细节，每个po类多了一个东西，就是xxxExample.java，这个类是给用户自定义sql是用的，后面我会提到。到这里就生成好了，下面我们就把生成的代码拷贝到自己的工程使用了，为了简便，这里我就拷贝ItemsMapper.java/ItemsMapper.xml/Items.java/ItemsExample.java这一类的，其他都一样。

3. 测试生成的代码

    我们针对ItemsMapper.java新建一个测试类，测试其中的几个方法：

 

public class ItemsMapperTest {

    private SqlSessionFactory sqlSessionFactory;

    @Before
    public void setUp() throws Exception {
        // 创建sqlSessionFactory
        String resource = "SqlMapConfig.xml"; // mybatis配置文件

        // 得到配置文件的流
        InputStream inputStream = Resources.getResourceAsStream(resource);

        // 创建会话工厂SqlSessionFactory,要传入mybaits的配置文件的流
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    }

    //普通的插入，跟我们之前的插入是一样的
    @Test
    public void testInsert() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        ItemsMapper itemsMapper = sqlSession.getMapper(ItemsMapper.class);

        Items items = new Items();
        items.setName("手机");
        items.setPrice(5000f);
        items.setCreatetime(new Date());
        itemsMapper.insert(items);
        sqlSession.commit();
        //还有一个insertSelective(items);方法，是插入的项不为空时，才将那个字段拼接到sql中
        //可以下自动生成的xml文件就知道了。
    }

    //自定义查询
    @Test
    public void testSelectByExample() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        ItemsMapper itemsMapper = sqlSession.getMapper(ItemsMapper.class);

        //自定义查询，这就用到了ItemsExample类了，里面有个Criteria内部类，专门用来封装自定义查询条件的
        ItemsExample itemsExample = new ItemsExample();
        ItemsExample.Criteria criteria = itemsExample.createCriteria();
        //andNameEqualTo相当于在sql中拼接一个“AND name=‘背包‘”
        //还有其他很多方法，都是用来自定义查询条件的，可以自己看一下不同的方法
        criteria.andNameEqualTo("背包");
        List<Items> itemsList = itemsMapper.selectByExample(itemsExample);
        System.out.println(itemsList);
    }

    //根据主键查询，跟原来一样
    @Test
    public void testSelectByPrimaryKey() {
        ItemsMapper itemsMapper = sqlSessionFactory.openSession().getMapper(ItemsMapper.class);
        Items items = itemsMapper.selectByPrimaryKey(1);
        System.out.println(items);
    }

    //根据主键更新item，跟原来一样
    @Test
    public void testUpdateByPrimaryKey() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        ItemsMapper itemsMapper = sqlSession.getMapper(ItemsMapper.class);
        Items items = itemsMapper.selectByPrimaryKey(1);
        items.setPrice(3540f);
        itemsMapper.updateByPrimaryKey(items);
        sqlSession.commit();
    }
}

 

可以看出，逆向工程生成的代码，基本上和之前使用的差不多，只不过它更规范一点，而且还多了自定义查询条件的java类，用起来还是挺方便的。关于mybatis的逆向工程就总结到这吧。