当前位置: 澳门新濠3559 > 编程 > 正文

用spring你可能还在写xml,mybatis初期使用比较麻烦

时间:2019-10-06 23:48来源:编程
正所谓,天下武术,唯快不破,在明日生活节奏更快的时代,大家也要尊重成效,也要追求三个 快 字(然而有个别地方依然不能够快的,不要当快男哦)。springboot正是能简化配置、敏捷

正所谓,天下武术,唯快不破,在明日生活节奏更快的时代,大家也要尊重成效,也要追求三个字(然而有个别地方依然不能够快的,不要当快男哦)。springboot正是能简化配置、敏捷开拓的东西。做同三个连串,用spring你大概还在写xml,用springboot的话你只怕早已做完在约妹子了!

这两日开发银行了贰个新品类因为项目组成员一向都接纳的是mybatis,即使个人相比较欣赏jpa这种极简的形式,不过为了项目保持统一性本领选型依旧定了 mybatis。到网络找了一下有关spring boot和mybatis组合的相干资料,五光十色的花样都有,看的人心累,结合了mybatis的法定demo和文档终于找到了最简的三种形式,花了一天时间总结后分享出去。
orm框架的真相是简化编制程序中操作数据库的编码,发展到最近基本上就剩两家了,二个是宣称能够不用写一句SQL的hibernate,多少个是能够灵活调试动态sql的mybatis,两个各有特点,在小卖部级系统开荒中可以依照供给灵活应用。开掘二个风趣的风貌:守旧公司基本上喜欢使用hibernate,互连网行当日常接纳mybatis。
hibernate特点正是享有的sql都用Java代码来变化,不用跳出程序去写(看)sql,有着编制程序的完整性,发展到最顶部就是spring data jpa这种格局了,基本上依照章程名就足以变动对应的sql了。
mybatis早期使用相比麻烦,要求各类配置文件、实体类、dao层映射关联、还会有第一次全国代表大会推别的配置。当然mybatis也意识了这种破绽,开始时期开垦了generator能够依据表结果自动生产实体类、配置文件和dao层代码,能够减轻部分开垦量;前期也实行了汪洋的优化能够运用注明了,自动管理dao层和配置文件等,发展到最最上部正是前几天要讲的这种方式了,mybatis-spring-boot-starter就是springboot mybatis能够完全批注不用配置文件,也能够简轻松单布署轻便上手。

这两日开发银行了三个新类型因为品种组成员一贯都选取的是mybatis,固然个人相比喜欢jpa这种极简的形式,不过为了项目保持统一性本领选型依然定了 mybatis。到互连网找了一晃关于spring boot和mybatis组合的有关材质,五光十色的花样都有,看的人心累,结合了mybatis的官方demo和文书档案终于找到了最简的二种形式,花了一天时间计算后享受出来。

这两日开发银行了贰个新品类因为项目组成员一贯都应用的是mybatis,纵然个人比较欣赏jpa这种极简的形式,可是为了项目保持统一性本事选型依然定了 mybatis。到网络找了一下关于spring boot和mybatis组合的有关资料,美妙绝伦的款式皆有,看的人心累,结合了mybatis的合法demo和文书档案终于找到了最简的二种情势,花了一天时间总计后分享出去。

springboot,提及底如故spring家族的,只可是用spring时我们要写大量的xml配置各类东西,而springboot不用写那个,直接写在application.properties或application.yml中就能够,也正是那么些复杂的计划springboot底层为我们安插好了,直接声美素佳儿(Friso)下就能够。

今日想想spring boot 便是牛逼呀,任何事物一旦涉及到spring boot都以化繁为简。

orm框架的面目是简化编制程序中操作数据库的编码,发展到前些天大概就剩两家了,二个是声称能够不用写一句SQL的hibernate,四个是足以灵活调节和测验动态sql的mybatis,两个各有特点,在市廛级系统开荒中得以依附供给灵活应用。开掘三个有趣的现象:古板厂家多数喜欢使用hibernate,互连网行业常见接纳mybatis。

orm框架的实质是简化编制程序中操作数据库的编码,发展到目前大约就剩两家了,三个是声称能够不用写一句SQL的hibernate,二个是足以灵活调节和测量试验动态sql的mybatis,两个各有特点,在店堂级系统开拓中得以依附需求灵活使用。开采贰个风趣的风貌:守旧公司基本上喜欢使用hibernate,网络行当常见选取mybatis。

1、springboot对静态能源的拍卖:springboot项目中静态资源的根目录是:src/main/resources/static

骨子里就是myBatis看spring boot这么火爆也支付出一套应用方案来凑凑吉庆,但这一凑确实化解了广大标题,使用起来着实顺畅了无数。mybatis-spring-boot-starter重要有二种减轻方案,一种是采用证明消除一切难题,一种是简化后的老传统。

hibernate特点正是兼备的sql都用Java代码来变化,不用跳出程序去写sql,有着编制程序的完整性,发展到最上边正是spring data jpa这种格局了,基本上遵照章程名就足以生成对应的sql了,有不太明白的能够看自个儿的上篇小说springboot:spring data jpa的选择。

hibernate特点正是负有的sql都用Java代码来扭转,不用跳出程序去写sql,有着编制程序的完整性,发展到最上方便是spring data jpa这种情势了,基本上遵照办法名就能够转移对应的sql了,有不太驾驭的能够看自个儿的上篇文章springboot:spring data jpa的利用。

静态能源如html页面、图片、js、css等都位居此文件夹或该公文夹的子文件夹下。举例在static下有water.jpg图片,在未曾配备视图分析器和做客根路线的气象下,在浏览器直接输入:http://localhost:8080/water.jpg就能够访谈该图形。

1 无配置文件阐明版

正是全体应用申明消除。

mybatis开始的一段时期使用相比劳苦,要求各类配置文件、实体类、dao层映射关联、还可能有一大推另外配置。当然mybatis也发觉了这种破绽,开始的一段时代开采了generator能够依靠表结果自动生产实体类、配置文件和dao层代码,能够减轻部分开垦量;早先时期也进行了大批量的优化能够动用注明了,自动管理dao层和配备文件等,发展到最上方正是先天要讲的这种格局了,mybatis-spring-boot-starter就是springboot mybatis能够完全讲授不用配置文件,也得以简简单单陈设轻巧上手。

mybatis早期使用相比较费心,供给种种配置文件、实体类、dao层映射关联、还应该有一大推其余配置。当然mybatis也发掘了这种破绽,开始的一段时期开拓了generator能够依照表结果自动生产实体类、配置文件和dao层代码,能够缓和部分开发量;早先时期也扩充了大气的优化可以应用证明了,自动管理dao层和布置文件等,发展到最顶部正是前些天要讲的这种情势了,mybatis-spring-boot-starter正是springboot mybatis能够完全讲解不用配置文件,也足以大致陈设轻易上手。

日常来说,会在static下建构pages文件夹用于寄存页面,js文件夹存放js代码,css文件夹寄放css。

1.1 项目信任

  1. 引进连接mysql的至关重要注重mysql-connector-java;
  2. 引进整合MyBatis的骨干正视mybatis-spring-boot-starter;
  3. 引进tk.mybatis 信任,完毕对实体类的增加和删除改查的代码;
  4. 引进pagerhelper 重视,完成分页效率。
<!--整合Mybatis开始-->
<!--1.引入整合MyBatis的核心依赖mybatis-spring-boot-starter -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.0</version>
</dependency>

<!--2.引入连接mysql的必要依赖mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.43</version>
</dependency>

<!--3.引入tk.mybatis 依赖,实现对实体类的增删改查的代码 -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>1.1.3</version>
</dependency>

<!--4.引入pagerhelper 依赖,实现分页功能 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.1.2</version>
</dependency>

<!--整合Mybatis结束-->

这段日子想想spring boot 正是牛逼呀,任何事物假使涉及到spring boot都以化繁为简。

今昔想想spring boot 正是牛逼呀,任何事物假诺涉及到spring boot都以化繁为简。

2、全局十二分捕获:当你会见页面出错开上下班时间,暗许是404或500以及以第一次全国代表大会串爱沙尼亚语,本人写了全局十二分捕获类就能够在阴差阳错开上下班时间呈现自个儿写的内容。只需求编写制定三个类拉长评释就能够,如下:

1.2 application.properties 增加相关布置

spring.datasource.url=jdbc:mysql://localhost:3306/tdf_db?characterEncoding=utf-8&serverTimezone=UTC&useSSL=false
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

#实体类扫描包
mybatis.type-aliases-package=com.pingkeke.springBoot.entity
#Mapper.xml文件扫描目录
mybatis.mapper-locations=classpath:mapper/*.xml
#驼峰命名
mybatis.configuration.mapUnderscoreToCamelCase=true

#tkmapper 工具类
mapper.mappers=com.pingkeke.springBoot.util.MyMapper
mapper.not-empty=false
mapper.identity=MYSQL
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

springboot会自动加载spring.datasource.*连锁配置,数据源就能够活动注入到sqlSessionFactory中,sqlSessionFactory会自动注入到Mapper中,对了您全数都毫不管了,直接拿起来使用就行了。

合法证实:MyBatis Spring-Boot-Starter will help you use MyBatis with Spring Boot实际上正是myBatis看spring boot这么火爆也支付出一套实施方案来凑凑欢腾,但这一凑确实解决了成千上万标题,使用起来的确顺畅了相当多。mybatis-spring-boot-starter首要有二种减轻方案,一种是应用申明化解一切难点,一种是简化后的老观念。

法定认证:MyBatis Spring-Boot-Starter will help you use MyBatis with Spring Boot

@ControllerAdvicepublic class GlobalExceptionHandler{ @ExceptionHandler(RuntimeException.class) @ResponseBody public Map<String,Object> resultError(){ Map<String,Object> modelMap = new HashMap<String,Object>(); modelMap.put("errCode",500); modelMap.put("errMsg","错误!"); return modelMap; }}

1.3 在起步类中加多对mapper包扫描@MapperScan

package com.pingkeke.springBoot;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * 在启动类中添加对mapper包扫描@MapperScan,Note by:CHENQP
 */
@SpringBootApplication
@MapperScan("com.pingkeke.springBoot.mapper")
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

要么间接在Mapper类上面增添注脚@Mapper,提出使用方面这种,不然各个mapper加个注明也挺艰苦的。

当然任何方式都亟需首先引进mybatis-spring-boot-starter的pom文件,未来风靡版本是1.1.1(刚好快到双11了 :)

骨子里便是myBatis看spring boot这么热门也支出出一套建设方案来凑凑喜庆,但这一凑确实化解了不胜枚举主题材料,使用起来着实顺畅了非常多。mybatis-spring-boot-starter首要有二种缓和方案,一种是选取申明消除任何难题,一种是简化后的老理念。

那实际是用了spring的万分文告。

1.4 开发Mapper

db

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for `users`
-- ----------------------------
DROP TABLE IF EXISTS `users`;
CREATE TABLE `users` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `userName` varchar(32) DEFAULT NULL COMMENT '用户名',
  `passWord` varchar(32) DEFAULT NULL COMMENT '密码',
  `user_sex` varchar(32) DEFAULT NULL,
  `nick_name` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=28 DEFAULT CHARSET=utf8;

entity

package com.pingkeke.springBoot.entity;

import com.pingkeke.springBoot.enums.UserSexEnum;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

/**
 * User.
 */

@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class User {

    private Long id;
    private String userName;
    private String passWord;
    private UserSexEnum userSex;
    private String nickName;

}

是最要害的一块,sql生产都在此间;

package com.pingkeke.springBoot.mapper;

import com.pingkeke.springBoot.entity.UserEntity;
import com.pingkeke.springBoot.enums.UserSexEnum;
import org.apache.ibatis.annotations.*;

import java.util.List;

/**
 * UserMapper.
 * sql生产都在这里
 *
 * 为了更接近生产我特地将user_sex、nick_name两个属性在数据库加了下划线和实体类属性名不一致,
 * 另外user_sex使用了枚举
 *
 * @Select 是查询类的注解,所有的查询均使用这个
 @Result 修饰返回的结果集,关联实体类属性和数据库字段一一对应,
 如果实体类属性和数据库属性名保持一致,就不需要这个属性来修饰。
 @Insert 插入数据库使用,直接传入实体类会自动解析属性到对应的值
 @Update 负责修改,也可以直接传入对象
 @delete 负责删除



 */
public interface UserMapper {

    @Select("SELECT * FROM users")
    @Results({
            @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
            @Result(property = "nickName", column = "nick_name")
    })
    List<UserEntity> getAll();

    @Select("SELECT * FROM users WHERE id = #{id}")
    @Results({
            @Result(property = "userSex",  column = "user_sex", javaType = UserSexEnum.class),
            @Result(property = "nickName", column = "nick_name")
    })
    UserEntity getOne(Long id);

    @Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})")
    void insert(UserEntity user);

    @Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}")
    void update(UserEntity user);

    @Delete("DELETE FROM users WHERE id =#{id}")
    void delete(Long id);
}

注意,使用#标记和$符号的两样:

<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version></dependency>

当然任何情势都亟需首先引进mybatis-spring-boot-starter的pom文件,以往新型版本是1.1.1

3、配置多情形:在其实支付进度中,经常恐怕有以下4个遭受:

1.5 使用

地点三步就着力做到了连带dao层开辟,使用的时候作为普通的类注入进来就足以了。

package com.pingkeke.springBoot.mapper;

import com.pingkeke.springBoot.entity.UserEntity;
import com.pingkeke.springBoot.enums.UserSexEnum;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

/**
 * UserMapperTest.
 */

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    /**
     *   在Idea的spring工程里,经常会遇到Could not autowire.
     * No beans of 'xxxx' type found的错误提示。但程序的编译和运行都是没有问题的,
     * 这个错误提示并不会产生影响。但红色的错误提示在有些有强迫症的程序员眼里,多多少少有些不太舒服。
     *
     * 解决方案
       降低Autowired检测的级别,将Severity的级别由之前的error改成warning或其它可以忽略的级别。

     */
    @Autowired
    private UserMapper UserMapper;

    @Test
    public void testInsert() throws Exception {
        UserMapper.insert(new UserEntity("aa", "a123456", UserSexEnum.MAN));
        UserMapper.insert(new UserEntity("bb", "b123456", UserSexEnum.WOMAN));
        UserMapper.insert(new UserEntity("cc", "b123456", UserSexEnum.WOMAN));

        Assert.assertEquals(3, UserMapper.getAll().size());
    }

    @Test
    public void testQuery() throws Exception {
        List<UserEntity> users = UserMapper.getAll();
        System.out.println(users.toString());
    }

    @Test
    public void testUpdate() throws Exception {

        String id= "30";
        Long userId = Long.valueOf(id).longValue();

        UserEntity user = UserMapper.getOne(userId);
        System.out.println(user.toString());

        user.setNickName("Bobby");
        UserMapper.update(user);
        Assert.assertTrue(("Bobby".equals(UserMapper.getOne(userId).getNickName())));
    }
}

好了下来分别介绍二种开垦方式

<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.1.1</version></dependency>
test ------------------ 本地开发环境sit ------------------ 测试环境pre ------------------ 预生产环境pid ------------------ 生产环境

2 整合Swagger2

无配置文件申明版正是一切应用表明消除。

好了下去分别介绍三种开拓方式

那正是说怎么样为分歧的生育情况布署分裂的布局文件呢?首先得有如下5个.properties 配置

2.1 添加Swagger2 依赖

<!--整合Swagger2-->
<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.4.0</version>
</dependency>

<!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.4.0</version>
</dependency>

1 增加相关maven文件

正是全体应用评释化解。

用spring你可能还在写xml,mybatis初期使用比较麻烦。文件:

2.2 创建Swagger2 配置类:

在Application.java 同级创造多个Swagger2 的配置类:

package com.pingkeke.springBoot;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * Swagger2 的配置类.
 */
@Configuration
@EnableSwagger2
public class Swagger2 {

    @Bean
    public Docket webApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("DemoAPI接口文档")
                .apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.pingkeke.springBoot.controller"))
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Demo使用Swagger2构建RESTful APIs")
                .description("用户服务")
                .contact(new Contact("Bobby", "http://petstore.swagger.io/v2/swagger.json", "pingkeke@163.com"))
                .version("1.0")
                .build();
    }
}
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <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>1.1.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency></dependencies>
    1. 累加相关maven文件
 application.properties ------------------ 总配置文件 application-test.properties ------------------ 本地 application-sit.properties ------------------ 测试 application-pre.properties ------------------ 预生产 application-pid.properties ------------------ 生产

2.3 在急需生成Api 的接口增添表明:

package com.pingkeke.springBoot.controller;

import com.pingkeke.springBoot.entity.UserEntity;
import com.pingkeke.springBoot.mapper.UserMapper;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * UserController.
 * spring boot如何做呢,只需要类添加 @RestController 即可,默认类中的方法都会以json的格式返回
 *
  http://localhost:8080/swagger-ui.html
 *
 */
@Api(tags = "用户管理相关接口")
@RestController
@RequestMapping(value="/users")     // 通过这里配置使下面的映射都在/users下
public class UserController {

    @Autowired
    private UserMapper userMapper;

    @ApiOperation(value="获取用户列表", notes="")
    @RequestMapping(value={""}, method= RequestMethod.GET)
    public List<UserEntity> getUserList() {
        List<UserEntity> users=userMapper.getAll();
        return users;
    }

    @ApiOperation(value="创建用户", notes="根据User对象创建用户")
    @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User")
    @RequestMapping(value="", method=RequestMethod.POST)
    public void postUser(@RequestBody UserEntity user) {
        userMapper.insert(user);
    }

    @ApiOperation(value="获取用户详细信息", notes="根据url的id来获取用户详细信息")
    @ApiImplicitParam(name = "id", value = "用户ID", required = true, paramType="path", dataType = "Long")
    @RequestMapping(value="/{id}", method=RequestMethod.GET)
    public UserEntity getUser(@PathVariable Long id) {
        UserEntity user=userMapper.getOne(id);
        return user;
    }

    @ApiOperation(value="更新用户详细信息", notes="根据url的id来指定更新对象,并根据传过来的user信息来更新用户详细信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "用户ID", required = true, paramType="path", dataType = "Long"),
            @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User")
    })
    @RequestMapping(value="/{id}", method=RequestMethod.PUT)
    public void putUser(@PathVariable Long id, @RequestBody UserEntity user) {
        userMapper.update(user);
    }

    @ApiOperation(value="删除用户", notes="根据url的id来指定删除对象")
    @ApiImplicitParam(name = "id", value = "用户ID", required = true, paramType="path", dataType = "Long")
    @RequestMapping(value="/{id}", method=RequestMethod.DELETE)
    public void deleteUser(@PathVariable Long id) {
        userMapper.delete(id);
    }
}

成功上述代码加多上,运行Spring Boot程序,访谈:http://localhost:8080/swagger-ui.html
。就会看到前文所展现的RESTful API的页面。我们得以再点开具体的API乞求,以POST类型的/users伏乞为例,可找到上述代码中大家布署的Notes消息以及参数user的陈说音讯,如下图所示。

澳门新濠3559 1

swagger-ui

一体化的pom包这里就不贴了,我们向来看源码

各样景况下的布局写到对应的安顿文件中,然后在总布署文件application.properties中经过

3 极简xml版本

极简xml版本保持映射文件的老思想,优化首要反映在不须求贯彻dao的是完结层,系统会自行依照章程名在光彩夺目文件中找对应的sql.

2、application.properties 加多相关安插

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <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>1.1.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <optional>true</optional> </dependency></dependencies>

spring.profiles.active =

3.1 配置

pom文件和上个版本同样,只是application.properties新添以下配置

#实体类扫描包
mybatis.type-aliases-package=com.pingkeke.springBoot.entity
#驼峰命名
mybatis.configuration.mapUnderscoreToCamelCase=true
#Mapper.xml文件扫描目录
mybatis.config-locations=classpath:mybatis/mybatis-config.xml
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml

钦定了mybatis基础配置文件和实体类映射文件的地点
mybatis-config.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>
    <typeAliases>
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
    </typeAliases>
</configuration>

此处也得以加多一些mybatis基础的布署

mybatis.type-aliases-package=com.neo.entityspring.datasource.driverClassName = com.mysql.jdbc.Driverspring.datasource.url = jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8spring.datasource.username = rootspring.datasource.password = root

全部的pom包这里就不贴了,我们平素看源码

读取不一样的配备文件,=test时读取application-test.properties=sit时读取application-sit.properties

3.2 增添User的照射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.pingkeke.springBoot.mapper.UserMapper" >

    <resultMap id="BaseResultMap" type="com.pingkeke.springBoot.entity.UserEntity" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="userName" property="userName" jdbcType="VARCHAR" />
        <result column="passWord" property="passWord" jdbcType="VARCHAR" />
        <result column="user_sex" property="userSex" javaType="com.pingkeke.springBoot.enums.UserSexEnum"/>
        <result column="nick_name" property="nickName" jdbcType="VARCHAR" />
    </resultMap>

    <sql id="Base_Column_List" >
        id, userName, passWord, user_sex, nick_name
    </sql>

    <select id="getAll" resultMap="BaseResultMap"  >
        SELECT
        <include refid="Base_Column_List" />
        FROM users
    </select>

    <select id="getOne" parameterType="java.lang.Long" resultMap="BaseResultMap" >
        SELECT
        <include refid="Base_Column_List" />
        FROM users
        WHERE id = #{id}
    </select>

    <insert id="insert" parameterType="com.pingkeke.springBoot.entity.UserEntity" >
        INSERT INTO
        users
        (userName,passWord,user_sex)
        VALUES
        (#{userName}, #{passWord}, #{userSex})
    </insert>

    <update id="update" parameterType="com.pingkeke.springBoot.entity.UserEntity" >
        UPDATE
        users
        SET
        <if test="userName != null">userName = #{userName},</if>
        <if test="passWord != null">passWord = #{passWord},</if>
        nick_name = #{nickName}
        WHERE
        id = #{id}
    </update>

    <delete id="delete" parameterType="java.lang.Long" >
        DELETE FROM
        users
        WHERE
        id =#{id}
    </delete>

</mapper>

事实上正是把上个版本中mapper的sql搬到了那边的xml中了。

springboot会自动加载spring.datasource.*有关安排,数据源就能够活动注入到sqlSessionFactory中,sqlSessionFactory会自动注入到Mapper中,对了您任何都并不是管了,直接拿起来使用就行了。

  • 2、application.properties 增添相关计划

4、整合jdbcTemplate:虽说jdbcTemplate用得没有多少了,也介绍一下如何结合。

3.3 编写Dao层的代码

package com.pingkeke.springBoot.mapper;

import com.pingkeke.springBoot.entity.UserEntity;

import java.util.List;

/**
 * UserMapper.
 * 对比上一步这里全部只剩了接口方法。


 */
public interface UserMapper {

    List<UserEntity> getAll();

    UserEntity getOne(Long id);

    void insert(UserEntity user);

    void update(UserEntity user);

    void delete(Long id);
}

比较上一步这里全数只剩了接口方法。

在起步类中加多对mapper包扫描@MapperScan

增添依赖:

3.4 使用

应用和上个版本没有别的差别。

@SpringBootApplication@MapperScan("com.neo.mapper")public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }}
mybatis.type-aliases-package=com.neo.entityspring.datasource.driverClassName = com.mysql.jdbc.Driverspring.datasource.url = jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8spring.datasource.username = rootspring.datasource.password = root
<!-- 要用jdbcTemplate,除了数据库依赖,添加这一个即可 --><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-jdbc</artifactId> <version>2.0.2.RELEASE</version></dependency>

3.5 怎样抉择

两种格局各有特点,评释版适合轻松便捷的方式,其实像今后盛行的这种微服务形式,一个微服务就能相应三个自已的数据库,多表连接查询的要求会大大的收缩,会更为相符这种方式
老古板方式比相符大型项目,能够灵活的动态生成SQL,便利调节SQL,也会有美观,洋洋洒洒的写SQL的感到。

可能直接在Mapper类上边增加申明@Mapper,提议利用方面这种,不然各样mapper加个评释也挺麻烦的

springboot会自动加载spring.datasource.*相关安顿,数据源就能自动注入到sqlSessionFactory中,sqlSessionFactory会自动注入到Mapper中,对了你整整都毫无管了,直接拿起来使用就行了。

流入使用:在急需利用的地点直接流入使用就可以,如下:

3、开垦Mapper第三步是最重大的一块,sql生产都在此处

在开发银行类中增加对mapper包扫描@MapperScan

public class test{ @AutoWired private JdbcTemplate jdbcTemplate; public void insertUser(String name,int age){ jdbcTemplate.update("insert into tb_user values",name,age); }}
public interface UserMapper { @Select("SELECT * FROM users") @Results({ @Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class), @Result(property = "nickName", column = "nick_name") }) List<UserEntity> getAll(); @Select("SELECT * FROM users WHERE id = #{id}") @Results({ @Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class), @Result(property = "nickName", column = "nick_name") }) UserEntity getOne; @Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})") void insert(UserEntity user); @Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}") void update(UserEntity user); @Delete("DELETE FROM users WHERE id =#{id}") void delete;}
@SpringBootApplication@MapperScan("com.neo.mapper")public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }}

5、整合jpa:*增添依赖:*

为了更类似生产本身专门将user_sex、nick_name八个特性在数据库加了下划线和实业类属性名不均等,其余user_sex使用了枚举

也许直接在Mapper类上边增多表明@Mapper,建议利用方面这种,不然各类mapper加个申明也挺麻烦的

<!-- 除了数据库依赖,添加这一个即可 --><dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> <version>2.0.2.RELEASE</version></dependency>

@Select 是查询类的讲解,全数的询问均运用那些

  • 3、开发Mapper

加注解:在开行类上增添七个注明:@EntityScan("实体类所在的包")@EnableJpaRepositories("dao层所在包名"),如下图:

@Result 修饰重返的结果集,关联实体类属性和数据库字段一一对应,借使实体类属性和数据库属性名保持一致,就没有须要那些本性来修饰。

其三步是最根本的一块,sql生产都在此间

@EnableJpaRepositories("com.zhu.dao")@EntityScan("com.zhu.entity")@SpringBootApplicationpublic class App{ public static void main(String[] args){ SpringApplication.run(App.class,args); }}

@Insert 插入数据库使用,直接传入实体类会自动深入分析属性到相应的值

public interface UserMapper { @Select("SELECT * FROM users") @Results({ @Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class), @Result(property = "nickName", column = "nick_name") }) List<UserEntity> getAll(); @Select("SELECT * FROM users WHERE id = #{id}") @Results({ @Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class), @Result(property = "nickName", column = "nick_name") }) UserEntity getOne; @Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{userSex})") void insert(UserEntity user); @Update("UPDATE users SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}") void update(UserEntity user); @Delete("DELETE FROM users WHERE id =#{id}") void delete;}

做到这两步就可以行使jpa了。

@Update 担负修改,也得以一向传入对象

为了更就好像生产自身非常将user_sex、nick_name八个属性在数据库加了下划线和实业类属性名不平等,别的user_sex使用了枚举

6、整合mybatis:

@delete 负担删除

  • @Select 是查询类的注释,全部的查询均使用这一个

加上借助:

打听更加的多属性参考这里

  • @Result 修饰再次来到的结果集,关联实体类属性和数据库字段一一对应,就算实体类属性和数据库属性名保持一致,就无需那么些脾性来修饰。
  • @Insert 插入数据库使用,间接传入实体类会自动深入分析属性到对应的值
  • @Update 担负修改,也得以直接传入对象
  • @delete 肩负删除
<dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.2</version></dependency>

注意,使用#标识和$符号的不如:

叩问越多属性参考这里

加注解:起步类上加@MapperScan("dao层所在包名"),若需求专门的工作帮忙,加上@EnableTransactionManagement,如下:

// This example creates a prepared statement, something like select * from teacher where name = ?;@Select("Select * from teacher where name = #{name}")Teacher selectTeachForGivenName(@Param String name);// This example creates n inlined statement, something like select * from teacher where name = 'someName';@Select("Select * from teacher where name = '${name}'")Teacher selectTeachForGivenName(@Param String name);

注意,使用#标志和$符号的区别:

@EnableTransactionManagement@MapperScan("com.zhu.dao")@SpringBootApplicationpublic class App{ public static void main(String[] args){ SpringApplication.run(App.class,args); }}

4、使用方面三步就着力到位了相关dao层开拓,使用的时候作为普通的类注入进来就足以了

// This example creates a prepared statement, something like select * from teacher where name = ?;@Select("Select * from teacher where name = #{name}")Teacher selectTeachForGivenName(@Param String name);// This example creates n inlined statement, something like select * from teacher where name = 'someName';@Select("Select * from teacher where name = '${name}'")Teacher selectTeachForGivenName(@Param String name);

若mybatis基于注解格局,那样就行了,能够一贯动用了,若mybatis基于xml情势,那将要在application.properties中布局如下内容:

@RunWith(SpringRunner.class)@SpringBootTestpublic class UserMapperTest { @Autowired private UserMapper UserMapper; @Test public void testInsert() throws Exception { UserMapper.insert(new UserEntity("aa", "a123456", UserSexEnum.MAN)); UserMapper.insert(new UserEntity("bb", "b123456", UserSexEnum.WOMAN)); UserMapper.insert(new UserEntity("cc", "b123456", UserSexEnum.WOMAN)); Assert.assertEquals(3, UserMapper.getAll; } @Test public void testQuery() throws Exception { List<UserEntity> users = UserMapper.getAll(); System.out.println(users.toString; } @Test public void testUpdate() throws Exception { UserEntity user = UserMapper.getOne; System.out.println(user.toString; user.setNickName; UserMapper.update; Assert.assertTrue(("neo".equals(UserMapper.getOne.getNickName; }}
  • 4、使用 上边三步就基本完结了有关dao层开采,使用的时候作为普通的类注入进来就能够了
#扫描dao层接口对应的xml文件mybatis.mapper-locations=classpath:mapper/*.xml#扫描mybatis的配置文件mybatis.config-location=classpath:mybatis-config.xml#起别名,写了这个在resultType中就不用写实体类包名,直接写类名即可mybatis.type-aliases-package=com.zhu.entity

源码中controler层有总体的增加和删除改查,这里就不贴了

7、整合非常多据源:整合许多据源日常才用包涵管理的措施,比方test1包使用数据源1,test2包使用数据源2。具体做法如下:

极简xml版本

@RunWith(SpringRunner.class)@SpringBootTestpublic class UserMapperTest { @Autowired private UserMapper UserMapper; @Test public void testInsert() throws Exception { UserMapper.insert(new UserEntity("aa", "a123456", UserSexEnum.MAN)); UserMapper.insert(new UserEntity("bb", "b123456", UserSexEnum.WOMAN)); UserMapper.insert(new UserEntity("cc", "b123456", UserSexEnum.WOMAN)); Assert.assertEquals(3, UserMapper.getAll; } @Test public void testQuery() throws Exception { List<UserEntity> users = UserMapper.getAll(); System.out.println(users.toString; } @Test public void testUpdate() throws Exception { UserEntity user = UserMapper.getOne; System.out.println(user.toString; user.setNickName; UserMapper.update; Assert.assertTrue(("neo".equals(UserMapper.getOne.getNickName; }}

第一来看档期的顺序的目录结构:

极简xml版本保持映射文件的老守旧,优化首要反映在无需完结dao的是促成层,系统会活动依据章程名在炫彩文件中找对应的sql.

源码中controler层有总体的增加和删除改查,这里就不贴了。

澳门新濠3559 2image

1、配置pom文件和上个版本一样,只是application.properties新扩展以下配置

源码在这里spring-boot-mybatis-annotation

配置:

mybatis.config-locations=classpath:mybatis/mybatis-config.xmlmybatis.mapper-locations=classpath:mybatis/mapper/*.xml

极简xml版本保持映射文件的老古板,优化主要反映在没有须要完成dao的是完成层,系统会自行依照章程名在炫人眼目文件中找对应的sql.

####整合多数据源###########数据源1:springboot1########spring.datasource.springboot1.driverClassName = com.mysql.jdbc.Driverspring.datasource.springboot1.url = jdbc:mysql:///springboot1spring.datasource.springboot1.username = #spring.datasource.springboot1.password = #######数据源2:springboot2########spring.datasource.springboot2.driverClassName = com.mysql.jdbc.Driverspring.datasource.springboot2.url = jdbc:mysql:///springboot2spring.datasource.springboot2.username = #spring.datasource.springboot2.password = #

点名了mybatis基础配置文件和实业类映射文件的地点

1、配置

数量源1是接二连三的springboot1数据库,数据源2是三翻五次springboot2数据库。以spring.datasource.springboot1.spring.datasource.springboot2.来差异数据源1和数据2。不过那属于自定义的竹签,springboot不会自动加载那四个数据源,由此要开创三个布局类去加载那五个数据源:

mybatis-config.xml 配置

pom文件和上个版本一样,只是application.properties新扩充以下配置

加载数据源:

<configuration> <typeAliases> <typeAlias alias="Integer" type="java.lang.Integer" /> <typeAlias alias="Long" type="java.lang.Long" /> <typeAlias alias="HashMap" type="java.util.HashMap" /> <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" /> <typeAlias alias="ArrayList" type="java.util.ArrayList" /> <typeAlias alias="LinkedList" type="java.util.LinkedList" /> </typeAliases></configuration>
mybatis.config-locations=classpath:mybatis/mybatis-config.xmlmybatis.mapper-locations=classpath:mybatis/mapper/*.xml
/** * 配置数据源1(springboot1)的类 * @author zhu * */@Configuration//表示只要是在test01包下的,都访问springboot1数据源@MapperScan(basePackages = "com.zhu.test01",sqlSessionFactoryRef = "springboot1SqlSessionFactory")public class DataSource1Config { //创建datasource @Bean(name = "springboot1DataSource") @ConfigurationProperties(prefix = "spring.datasource.springboot1") @Primary public DataSource testDataSource() { return DataSourceBuilder.create; } //创建SqlSessionFactory并注入datasource @Bean(name = "springboot1SqlSessionFactory") @Primary public SqlSessionFactory testSqlSessionFactory(@Qualifier("springboot1DataSource") DataSource dataSource) throws Exception{ SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } //创建事物管理并注入dataSource @Bean(name = "springboot1TransactionManager") @Primary public DataSourceTransactionManager testTransactionManager(@Qualifier("springboot1DataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } //创建事物管理并注入sqlSessionFactory @Bean(name = "springboot1SqlSessionTemplate") @Primary public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("springboot1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); }}

/** * 配置数据源2(springboot2)的类 * @author zhu * */@Configuration//表示只要是在test02包下的,都访问springboot2数据源@MapperScan(basePackages = "com.zhu.test02",sqlSessionFactoryRef = "springboot2SqlSessionFactory")public class DataSource2Config { //创建datasource @Bean(name = "springboot2DataSource") @ConfigurationProperties(prefix = "spring.datasource.springboot2") public DataSource testDataSource() { return DataSourceBuilder.create; } //创建SqlSessionFactory并注入datasource @Bean(name = "springboot2SqlSessionFactory") public SqlSessionFactory testSqlSessionFactory(@Qualifier("springboot2DataSource") DataSource dataSource) throws Exception{ SqlSessionFactoryBean bean = new SqlSessionFactoryBean(); bean.setDataSource(dataSource); return bean.getObject(); } //创建事物管理并注入dataSource @Bean(name = "springboot2TransactionManager") public DataSourceTransactionManager testTransactionManager(@Qualifier("springboot2DataSource") DataSource dataSource) { return new DataSourceTransactionManager(dataSource); } //创建事物管理并注入sqlSessionFactory @Bean(name = "springboot2SqlSessionTemplate") public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("springboot2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception { return new SqlSessionTemplate(sqlSessionFactory); }}

此地也可以拉长一些mybatis基础的配置

点名了mybatis基础配置文件和实体类映射文件的地址

如此那般就完了了那多个数据源的加载,由于有@MapperScan指定包,prefix =... 钦赐加载哪个数据源,所以就可以落到实处test01包下的就利用springboot1以此数据库,test02包下的就选拔springtboot2数据库。至此就达成了当先二分之一据源的结缘。注意在那之中二个数据源的加载时要加上@Primary批注,不然会报错。

2、增添User的照耀文件

mybatis-config.xml 配置:

如上正是springboot常用的有个别效率,通过结合方面那三个技能一定早就感受到了它的简便,听别人说spring boot是后来的取向,趁早精晓!

<mapper namespace="com.neo.mapper.UserMapper" > <resultMap type="com.neo.entity.UserEntity" > <id column="id" property="id" jdbcType="BIGINT" /> <result column="userName" property="userName" jdbcType="VARCHAR" /> <result column="passWord" property="passWord" jdbcType="VARCHAR" /> <result column="user_sex" property="userSex" javaType="com.neo.enums.UserSexEnum"/> <result column="nick_name" property="nickName" jdbcType="VARCHAR" /> </resultMap> <sql > id, userName, passWord, user_sex, nick_name </sql> <select resultMap="BaseResultMap" > SELECT <include ref /> FROM users </select> <select parameterType="java.lang.Long" resultMap="BaseResultMap" > SELECT <include ref /> FROM users WHERE id = #{id} </select> <insert parameterType="com.neo.entity.UserEntity" > INSERT INTO users (userName,passWord,user_sex) VALUES (#{userName}, #{passWord}, #{userSex}) </insert> <update parameterType="com.neo.entity.UserEntity" > UPDATE users SET <if test="userName != null">userName = #{userName},</if> <if test="passWord != null">passWord = #{passWord},</if> nick_name = #{nickName} WHERE id = #{id} </update> <delete parameterType="java.lang.Long" > DELETE FROM users WHERE id =#{id} </delete> </mapper>
<configuration> <typeAliases> <typeAlias alias="Integer" type="java.lang.Integer" /> <typeAlias alias="Long" type="java.lang.Long" /> <typeAlias alias="HashMap" type="java.util.HashMap" /> <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" /> <typeAlias alias="ArrayList" type="java.util.ArrayList" /> <typeAlias alias="LinkedList" type="java.util.LinkedList" /> </typeAliases></configuration>

如上内容属于民用笔记整理,如有错误,应接探究指正!

实际正是把上个版本中mapper的sql搬到了那边的xml中了

此间也足以增加一些mybatis基础的配置

3、编写Dao层的代码

2、增加User的投射文件

public interface UserMapper { List<UserEntity> getAll(); UserEntity getOne; void insert(UserEntity user); void update(UserEntity user); void delete;}
<mapper namespace="com.neo.mapper.UserMapper" > <resultMap type="com.neo.entity.UserEntity" > <id column="id" property="id" jdbcType="BIGINT" /> <result column="userName" property="userName" jdbcType="VARCHAR" /> <result column="passWord" property="passWord" jdbcType="VARCHAR" /> <result column="user_sex" property="userSex" javaType="com.neo.enums.UserSexEnum"/> <result column="nick_name" property="nickName" jdbcType="VARCHAR" /> </resultMap> <sql > id, userName, passWord, user_sex, nick_name </sql> <select resultMap="BaseResultMap" > SELECT <include ref /> FROM users </select> <select parameterType="java.lang.Long" resultMap="BaseResultMap" > SELECT <include ref /> FROM users WHERE id = #{id} </select> <insert parameterType="com.neo.entity.UserEntity" > INSERT INTO users (userName,passWord,user_sex) VALUES (#{userName}, #{passWord}, #{userSex}) </insert> <update parameterType="com.neo.entity.UserEntity" > UPDATE users SET <if test="userName != null">userName = #{userName},</if> <if test="passWord != null">passWord = #{passWord},</if> nick_name = #{nickName} WHERE id = #{id} </update> <delete parameterType="java.lang.Long" > DELETE FROM users WHERE id =#{id} </delete></mapper>

相比上一步这里整个只剩了接口方法

其实正是把上个版本中mapper的sql搬到了此处的xml中了

4、使用

3、编写Dao层的代码

动用和上个版本没有任何不相同,我们就看代码吧

public interface UserMapper { List<UserEntity> getAll(); UserEntity getOne; void insert(UserEntity user); void update(UserEntity user); void delete;}

xml配置版本:

相比较上一步这里整个只剩了接口方法

何以抉择

4、使用

三种方式各有特点,表明版切合轻便高效的情势,其实像未来盛行的这种微服务形式,三个微服务就能够相应三个自已的数据库,多表连接查询的要求会大大的裁减,会特别切合这种形式。

使用和上个版本未有别的差距,大家就看代码吧

老古板格局比符合大型项目,能够灵活的动态生成SQL,方便调节SQL,也会有雅观,洋洋洒洒的写SQL的痛感。

xml配置版本

全部代码地址:

二种情势各有特点,评释版符合轻松飞速的形式,其实像以后流行的这种微服务格局,三个微服务就能相应贰个自已的数据库,多表连接查询的供给会大大的缩短,会更为符合这种情势。

澳门新濠3559,更加的多参谋剧情:

老古板情势比符合大型项目,能够灵活的动态生成SQL,方便调度SQL,也可以有美观,洋洋洒洒的写SQL的感到到。

完全代码地址

  • Spring Boot系列:spring data jpa的使用
  • Spring Boot连串:thymeleaf使用详解
  • Spring Boot系列:Spring Boot中Redis的使用
  • Spring Boot类别:web综合开垦
  • Spring Boot系列:Spring Boot 入门篇

编辑:编程 本文来源:用spring你可能还在写xml,mybatis初期使用比较麻烦

关键词: 澳门新濠3559