• SpringBoot2.x 自动化生成代码整合Mybatis

    前言

    Mybatis 是一个持久层ORM框架，负责Java与数据库数据交互，也可以简易理解为中介，相对于它，还有个中介是hibernate,不过在mybatis中sql语句的灵活性，可优化性比较强，这也是现在大多数人选择的原因。

    1. mapper.xml、dao接口、实体类自动生成

    下载 pan.baidu.com/s/1JY7Xduk5… 工具包

    1.1 修改配置文件generator.xml

    解压之后,这里把文件拷贝到了C:\resources\generator文件夹下,以下称为"当前文件目录"
    一次配置,终身受益

    generator.xml

    1. "1.0" encoding="UTF-8"?>
    2. generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
    3. <generatorConfiguration>
    4.     
    5.     <classPathEntry location="C:\resources\generator\mysql-connector-java-5.1.34.jar" />
    6.     
    7.     
    8.     <context id="DB2Tables" targetRuntime="MyBatis3">
    9.         <commentGenerator>
    10.             
    11.             <property name="suppressDate" value="true"/>
    12.             
    13.             <property name="suppressAllComments" value="true"/>
    14.         commentGenerator>
    15.         
    16.         <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/ceilan" userId="root" password="123456">
    17.         
    18.         jdbcConnection>
    19.         
    20.         <javaTypeResolver>
    21.             <property name="forceBigDecimals" value="false" />
    22.         javaTypeResolver>
    23.         
    24.         <javaModelGenerator targetPackage="com.example.entity" targetProject="C:\resources\generator\src">
    25.             <property name="enableSubPackages" value="true" />
    26.             <property name="trimStrings" value="true" />
    27.         javaModelGenerator>
    28.         
    29.         <sqlMapGenerator targetPackage="mapping" targetProject="C:\resources\generator\src">
    30.             <property name="enableSubPackages" value="true" />
    31.         sqlMapGenerator>
    32.         
    33.         <javaClientGenerator type="XMLMAPPER" targetPackage="com.example.dao" targetProject="C:\resources\generator\src">
    34.             <property name="enableSubPackages" value="true" />
    35.         javaClientGenerator>
    36.         
    37.         <table tableName="area" domainObjectName="Area" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false" />
    38.     context>
    39. generatorConfiguration>
    40.

    1.2 用Java运行自动生成

    在当前目录下打开cmd命令,运行如下
    注 : windows系统可直接执行 [ 生成.bat ] 批处理文件

    1. java -jar mybatis-generator-core-1.3.2.jar -configfile generator.xml -overwrite
    2.

    然后把当前目录src下的com文件夹拷贝到项目文件夹下
    把mapping文件拷贝到resources文件夹下

    目录结构如上

    2.集成Mybatis框架

    2.1 引入依赖

    1. compile "mysql:mysql-connector-java:5.1.39"
    2. compile 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.2.0'
    3.

    2.2 启动类DemoApplication.java增加扫描配置

    1. package com.example;
    2.  
    3. import org.mybatis.spring.annotation.MapperScan;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7.  
    8. @SpringBootApplication
    9. // mapper接口 扫描包配置
    10. @MapperScan(value = "com.example.dao")
    11. public class DemoApplication {
    12.     public static void main(String[] args) {
    13.         SpringApplication.run(DemoApplication.class, args);
    14.     }
    15. }
    16.

    2.3 添加项目首页index.html

    在resources的templates文件中新建index.html

    index.html

    1. <!DOCTYPE html>
    2. <html lang="en">
    3. <head>
    4.     <meta charset="UTF-8">
    5.     <title>Title</title>
    6. </head>
    7. <body>
    8.     <h1>Welcome SpringBoot</h1>
    9. </body>
    10. </html>
    11.

    然后在 DemoApplication 启动类中添加

    1.     //欢迎页面 首页
    2.     @RequestMapping("/")
    3.     public String index(){
    4.         return "index";
    5.     }
    6.

    之前已经在application.yml中配置了资源映射设置,如下

    1. spring: 
    2.   mvc:
    3.     view:
    4.       suffix: .html
    5.   resources:
    6.     static-locations: classpath:/templates
    7.

    所以现在的项目启动访问 http://localhost:8080/ 是可以直接访问到首页的

    3.添加业务层和控制层实现CRUD(增删改查)

    增加业务逻辑层包service以及在其下增加impl包用来实现其接口

    3.1业务逻辑层接口 AreaService.java

    1. package com.example.service;
    2.  
    3. import com.example.entity.Area;
    4.  
    5. /**
    6.  * 这里给dao层的代码拷贝过来先使用
    7.  * created by cfa  2018-11-08 下午 9:56
    8.  **/
    9. public interface AreaService {
    10.  
    11.     int deleteByPrimaryKey(Integer id);
    12.  
    13.     int insert(Area record);
    14.  
    15.     int insertSelective(Area record);
    16.  
    17.     Area selectByPrimaryKey(Integer id);
    18.  
    19.     int updateByPrimaryKeySelective(Area record);
    20.  
    21.     int updateByPrimaryKey(Area record);
    22. }
    23.

    3.2业务层实现类 AreaServiceImpl.java

    1. package com.example.service.impl;
    2.  
    3. import com.example.dao.AreaMapper;
    4. import com.example.entity.Area;
    5. import com.example.service.AreaService;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.io.Serializable;
    10.  
    11. /**
    12.  * 这里的@Service注解相当于自动注册到Spring的Bean
    13.  * 相当于原来的Application.xml里的 
    14.  * created by cfa  2018-11-08 下午 9:58
    15.  **/
    16. @Service
    17. public class AreaServiceImpl implements AreaService, Serializable {
    18.  
    19.     private final AreaMapper areaMapper;
    20.  
    21.     @Autowired
    22.     public AreaServiceImpl(AreaMapper areaMapper) {
    23.         this.areaMapper = areaMapper;
    24.     }
    25.  
    26.     @Override
    27.     public int deleteByPrimaryKey(Integer id) {
    28.         return areaMapper.deleteByPrimaryKey(id);
    29.     }
    30.  
    31.     @Override
    32.     public int insert(Area record) {
    33.         return areaMapper.insert(record);
    34.     }
    35.  
    36.     @Override
    37.     public int insertSelective(Area record) {
    38.         return areaMapper.insertSelective(record);
    39.     }
    40.  
    41.     @Override
    42.     public Area selectByPrimaryKey(Integer id) {
    43.         return areaMapper.selectByPrimaryKey(id);
    44.     }
    45.  
    46.     @Override
    47.     public int updateByPrimaryKeySelective(Area record) {
    48.         return areaMapper.updateByPrimaryKeySelective(record);
    49.     }
    50.  
    51.     @Override
    52.     public int updateByPrimaryKey(Area record) {
    53.         return areaMapper.updateByPrimaryKey(record);
    54.     }
    55. }
    56.

    3.3控制层的AreaController.java

    1. package com.example.controller;
    2.  
    3. import com.example.entity.Area;
    4. import com.example.service.AreaService;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.web.bind.annotation.RequestMapping;
    7. import org.springframework.web.bind.annotation.RestController;
    8.  
    9. @RestController
    10. @RequestMapping("area")
    11. public class AreaController {
    12.  
    13.     private final AreaService areaService;
    14.  
    15.     @Autowired
    16.     public AreaController(AreaService areaService) {
    17.         this.areaService = areaService;
    18.     }
    19.  
    20.     @RequestMapping("query")
    21.     public Area areaList(){
    22.         return areaService.selectByPrimaryKey(1);
    23.     }
    24.  
    25. }
    26.

    看到这里，想必看到很多次@Autowired，@Service等注解了,这就是Spring的两大核心之一的IOC(Inversion of Control),也就是DI依赖注入；
    Spring的两大核心AOP和IOC大家面试的时候也基本都有问到，到这里你IOC就不用头疼了；

    在Spring之前我们写代码，用到某个类，我们都需要去new一下，现在有个叫Spring，我把控制权交给它，OK,然后在给业务层盖上章（加注解），然后让这个叫Spring的家伙开始工作的时候，交给他去做，控制层需要逻辑A,OK,之前我们已经在控制层用DI注入了A，Spring就会把A的调用给控制层，下面说松紧耦合度，Spring之前，到处写的都是new新建对象，修改一个类很难，现在随意修改，只需要盖个章（DI），让Spring去管就可以了,你现在要问我原理，那些文邹邹的，后续在研究研究，原理相当于文言文，只有研究透了，才能用大家都理解的话写出来。

    业务层提供的接口加实现类就是为了实现松耦合，不然一个类就解决了，就像一个手机，坏了，里面的电池，屏幕，主板什么的拆下来还能用，这就是松耦合。

    4.热部署插件

    问题：你为什么不选择springboot自带的热部署插件
    答： 和之前的朋友问我的一样，问我为啥不把生成代码的插件放在项目中，一个项目还好，你要是写了多个项目，一个一个去部署，麻烦不，所以一次配置，一劳永逸。

    5.关于AOP——Spring的又一大核心

    面向切面编程（AOP是Aspect Oriented Program的首字母缩写）我们知道，面向对象的特点是继承、多态和封装.而封装就要求将功能分散到不同的对象中去，这在软件设计中往往称为职责分配.实际上也就是说，让不同的类设计不同的方法。这样代码就分散到一个个的类中去了。这样做的好处是降低了代码的复杂程度，使类可重用.但是人们也发现，在分散代码的同时，也增加了代码的重复性.什么意思呢？比如说，我们在两个类中，可能都需要在每个方法中做日志。按面向对象的设计方法，我们就必须在两个类的方法中都加入日志的内容。也许他们是完全相同的，但就是因为面向对象的设计让类与类之间无法联系，而不能将这些重复的代码统一起来。 也许有人会说，那好办啊，我们可以将这段代码写在一个独立的类独立的方法里，然后再在这两个类中调用。但是，这样一来，这两个类跟我们上面提到的独立的类就有耦合了，它的改变会影响这两个类。那么，有没有什么办法，能让我们在需要的时候，随意地加入代码呢？这种在运行时，动态地将代码切入到类的指定方法、 指定位置上的编程思想就是面向切面的编程。 一般而言，我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。 这样看来，AOP其实只是OOP的补充而已。OOP从横向上区分出一个个的类来，而AOP则从纵向上向对象中加入特定的代码。有了AOP，OOP变得立体了。如果加上时间维度，AOP使OOP由原来的二维变为三维了，由平面变成立体了。从技术上来说，AOP基本上是通过代理机制实现的。 AOP在编程历史上可以说是里程碑式的，对OOP编程是一种十分有益的补充 引自：xiaobashagua.iteye.com/blog/196368…你问我为啥排这么紧，哈哈，好东西是留给有耐心的人看的，如果你把这篇文章的IOC和AOP仔细看了，你会对这俩的理解又深了一个层次

  • 相关阅读:
    2022前端面试题整理总结~
    学习MySQL的第五天：多表查询（基础篇）
    Node.js躬行记（19）——KOA源码分析（上）
    stm32编写Modbus步骤
    聊聊关于图像分割的损失函数 - BCEWithLogitsLoss
    iOS开发之打包上传到App Store——（一）各种证书的理解
    Mybatis用到的设计模式
    linux中的压缩解压命令：gzip,tar,zip,bzip2
    springboot项目打包优化，将所有第三方包单独打包至lib目录
    【MCAL_CANDriver】-2.1-硬件过滤(Hardware Filter)详述及配置
  • 原文地址：https://blog.csdn.net/jcc4261/article/details/127976193