16.SSM框架集~MybatisPlus初步

16.SSM框架集~MybatisPlus初步

本文是上一篇文章的后续,详情点击该链接

MybatisPlus

        Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。官方文档说的愿景是成为 Mybatis 最好的搭档。

MyBatis和Mybatis Plus的使用比较

        MybatisPlus包含了Mybatis的所有功能，也就说在MybatisPlus中我们仍然可以按照Mybatis的方式来完成数据库的操作(无侵入)。

        MybatisPlus的数据库操作的Mapper层的接口只需要继承BaseMapper接口，就自动的拥有了当前对应的表的基本的CRUE操作，无需声明接口方法及其xml文件，极大的提升了开发效率(MybatisPlus是通过实体类来逆向动态生成对应的表的基本的Sql语句)

MybatisPlus特性

        无侵入:只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑

        损耗小:启动即会自动注入基本CURD,性能基本无损耗，直接面向对象操作

        强大的CRUD操作:内置通用Mapper.通用Service,仅仅通过少量配置即可实现单表大部分CRUD操作，更有强大的条件构造器，满足各类使用需求

        支持Lambda形式调用:通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错

        支持主键自动生成:支持多达4种主健策略(内含分布式唯一ID 生成器. Sequence)，可自由配置，完美解决主键问题

        支持ActiveRecord模式:支持ActiveRecord形式调用，实体类只需继承Model类即可进行强大的CRUD操作

        支持自定义全局通用操作:支持全局通用方法注入( Write once, use anywhere )

        无内置代码生成器:采用代码或者Maven插件可快速生成Mapper. Model. Service、Controller层代码，支持模板引擎，更有超多自定义配置等您来使用

        内置分页插件:基于MyBatis物理分页,开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询

        分页插件支持多种数据库:支持MySQL. MariaDB. Oracle. DB2. H2、 HSQL. sQlite. Postgre.SQLServer等多种数据库

        内置性能分析插件:可输出Sql语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

        内置全局拦截插件:提供全表delete、update操作智能分析阻断，也可自定义拦截规则，预防误操作

MybatisPlus依赖

        <!--MyBatisPlus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.3.2</version>
        </dependency>

代码实现

新建一个jar项目

导入需要的依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.alvin</groupId>
    <artifactId>MybatisPlusProject</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <mysql-version>8.0.11</mysql-version>
        <mybatis-version>3.5.2</mybatis-version>
        <spring-version>5.2.2.RELEASE</spring-version>
        <mybatis-spring-version>2.0.4</mybatis-spring-version>
        <slf4j-version>1.7.25</slf4j-version>
        <junit-version>4.12</junit-version>
    </properties>

    <dependencies>
        <!--mysql的驱动依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql-version}</version>
        </dependency>
        <!--mybatis的核心依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis-version}</version>
        </dependency>
        <!--springIOC的核心依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <!--spring-jdbc连依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <!--spring-test依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring-version}</version>
        </dependency>
        <!--spring-webmvc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring-version}</version>
        </dependency>

        <!--mybatis连接spring的依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring-version}</version>
        </dependency>

        <!--日志依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j-version}</version>
        </dependency>

        <!--单元测试的依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>${junit-version}</version>
            <scope>test</scope>
        </dependency>

        <!--AOP的命名空间依赖-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

        <!--文件上传组件的依赖-->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>

        <!--跨服务文件访问依赖-->
        <dependency>
            <groupId>com.sun.jersey</groupId>
            <artifactId>jersey-client</artifactId>
            <version>1.19</version>
        </dependency>

        <!--MyBatisPlus依赖-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.3.2</version>
        </dependency>

    </dependencies>


</project>

配置applicationContext-mybatis.xml

<?xml version="1.0" encoding="UTF8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

        <!--把jdbc.properties文件引入-->
        <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

       <!--[A]连接数据库 获得数据源-->
       <bean id="ds" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
           <property name="driverClassName" value="${m_driver}"></property>
           <property name="url" value="${m_url}"></property>
           <property name="username" value="${m_uname}"></property>
           <property name="password" value="${m_pwd}"></property>
       </bean>

       <!--[B]获得sqlsession工厂-->
       <bean id="factory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean" >
           <!--引入全局策略-->
           <property name="globalConfig" ref="config"></property>

           <!--配置分页插件-->
           <property name="plugins">
               <array>
                   <bean class="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor">
                       <!--设置连接数据库方言-->
                       <property name="dialectType" value="mysql"></property>
                   </bean>
               </array>
           </property>

           <property name="dataSource" ref="ds"></property>
           <property name="typeAliasesPackage" value="com.alvin.pojo"></property>
       </bean>


      <!--配置全局策略-->
      <bean id="config" class="com.baomidou.mybatisplus.core.config.GlobalConfig">
          <property name="dbConfig">
              <bean id="db" class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                  <!--表名称的前缀-->
                 <!-- <property name="tablePrefix" value="t_"></property>-->
                  <!--主键自增的操作-->
                  <property name="idType" value="AUTO"></property>
              </bean>
          </property>
      </bean>



      <!--[C]扫描mapper文件-->
      <bean id="mapper" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          <property name="sqlSessionFactoryBeanName" value="factory"></property>
          <property name="basePackage" value="com.alvin.mapper"></property>
      </bean>
</beans>

编写实体类

public class Flower  implements Serializable {
    //指定当前字段是主键
    @TableId(type = IdType.AUTO)
    private   Integer  id;
    //@TableField(value = "t_name")
    private  String  name;
    private   Double  price;
    private   String  production;
}//get set就不再文章里面写了

编写Mapper层

public interface FlowerMapper extends BaseMapper<Flower> { }

       写到这里会不会感觉很奇怪?为什么Mapper层一行代码都没有，仅仅只是继承了一个BaseMapper类?好吧,我们现在点进去看一看

       在这里面我们可以看到很多熟悉的方法,没错,继承了这个类之后,对于增删查改等一些简单的操作,从此不再需要我们手动来写Sql语句了~我们来测试类看一看

Test测试类

@ContextConfiguration(locations ={"classpath:applicationContext-mybatis.xml"} )
@RunWith(SpringJUnit4ClassRunner.class)
public class TestA {
    @Autowired
    private FlowerMapper  flowerMapper;

    @Test
    public void testFlower1(){
        List<Flower> list = flowerMapper.selectList(null);
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

        你看,数据传过来了~

MyBatis Plus 中的CRUD

查询操作

查询全部信息

        List<Flower> list = flowerMapper.selectList(null);
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

根据ID查询信息

SELECT id,name,price,production FROM flower WHERE id=?

		Flower flower = flowerMapper.selectById(10002);
		System.out.println("根据ID查询: " + flower);

批量查询

SELECT id,name,price,production FROM flower WHERE id IN ( ? , ? )

        List<Integer>listS = new ArrayList<Integer>();
        listS.add(10001); listS.add(10003);
        list = flowerMapper.selectBatchIds(listS);
        System.out.println("批量查询" + list);

Map查询

SELECT id,name,price,production FROM flower WHERE name = ? AND id = ?

        Map<String,Object> map = new HashMap<String, Object>();
        map.put("id",10005);
        map.put("name","西兰花");
        List<Flower> list1 = flowerMapper.selectByMap(map);
        System.out.println("Map查询" + list1);

自定义查询条件

SELECT id,name,price,production FROM flower WHERE (name = ? OR id = ?)

        //自定义查询
        QueryWrapper<Flower> queryWrapper = new QueryWrapper<Flower>();
        queryWrapper.eq("name","西兰花").or().eq("id",10005);
        List<Flower> list2 = flowerMapper.selectList(queryWrapper);
        System.out.println(list2);

添加操作

 public void Insert(){
        //在添加的时候需要注意  ，如果数据库中主键是自增的，我们一定要在
        //实体类中指定主键属性为 @TableId(type = IdType.AUTO)
        Flower  flower=new Flower();
        flower.setName("XXX");
        flower.setPrice((double) 18);
        flower.setProduction("中国");
        //INSERT INTO flower ( name, price, production ) VALUES ( ?, ?, ? )
        int insert = flowerMapper.insert(flower);
    }

修改操作

    public void Update(){
        Flower flower = new Flower();
        flower.setId(10001);
        flower.setName("玫瑰花");
        flowerMapper.updateById(flower);
    }

自定义修改条件

        //指定修改条件
        //UPDATE flower SET production=? WHERE (name = ?)
        QueryWrapper queryWrapper=new QueryWrapper();
        queryWrapper.eq("name","西兰花");
        flowerMapper.update(f,queryWrapper);

删除操作

    public void Delete(){
        //[1]根据ID进行删除操作
        //DELETE FROM flower WHERE id=?
       // flowerMapper.deleteById(5);
        List<Integer>  list=new ArrayList<Integer>();
        list.add(10001);
        list.add(10003);
        //[2]根据ID进行批量删除操作
        //DELETE FROM flower WHERE id IN ( ? , ? )
        flowerMapper.deleteBatchIds(list);
        //[3]多条件删除操作，条件之间使用的是and进行关联
        //flowerMapper.deleteByMap();
        //[4]自定义删除条件
        //DELETE FROM flower WHERE (name = ? OR production = ?)
        QueryWrapper<Flower>  queryWrapper=new QueryWrapper();
        queryWrapper.eq("name","xxx").or().eq("production","XXX");
        flowerMapper.delete(queryWrapper);
    }