SpringBoot(一)

Springboot(一)

什么是SpringBoot

SpringBoot是Spring项目中的一个子工程,与Spring-famework同属于Spring的产品

用一些固定的方式来构建生产级别的Spring应用。SpringBoot推崇约定大于配置的方式以便于能够尽可能快速的启动并运行程序

我们把Spring Boot称为搭建程序的脚手架,最主要作用就是帮我们快速的构建庞大的项目,并且尽可能的减少一切xml配置,做到开箱即用。

为什么要用SpringBoot

我们Java一直被人诟病臃肿、麻烦。往往我们需要开发一个Java项目时,总是需要大量的工作来进行配置和构建。主要原因是:

  • 复杂的配置
  • 混乱的依赖管理

SpringBoot的特点

我们可以使用SpringBoot创建Java应用,并使用java -jar启动,就能得到一个生产级别的web工程

  • 为所有Spring的开发者提供一个非常快速的、广泛接受的入门体验
  • 开箱即用(启动器starter-其实就是SpringBoot提供的一个jar包,并通过自己设置.properties参数来达到配置的目的)
  • 提供一些大型项目中常见的非功能性特性
  • 无需xml配置,绝对没有代码生成

快速入门

快速创建SpringBoot项目

idea快速创建SpringBoot项目

选择web

SpringBoot项目结构
  • 启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootFastcreateApplication {

    public static void main(String[] args) {

        SpringApplication.run(SpringbootFastcreateApplication.class, args);
    }

}

启动类分析

  1. @SpringBootApplication:证明这工程是一个springboot的应用
  2. main方法:SpringApplication.run
    构造一个springApplication,执行SpringApplication的run方法

手动创建SpringBoot项目

  1. 创建一个Maven工程 作为父工程


    image.png
  2. 引入spring父工程依赖
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-parent</artifactId>
    <version>2.2.2.RELEASE</version>
</parent>
  1. 添加一个起步依赖(引入start-web、java的版本1.8)
    为了让SpringBoot帮我们完成各种自动配置,我们必须引入SpringBoot提供的自动配置依赖。也就是启动器。因为我们是web项目,所以我们在这里引入web启动器
<!--2、JAVA的版本-->
<properties>
    <java.version>1.8</java.version>
</properties>

<!--3、起步依赖-->
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>
  • 注意这里我们不需要指定版本的信息,因为SpringBoot的父工程已经对版本进行管理了
  1. 创建一个启动类
package com.probuing.self;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author wangxin
 * @date 2020/1/11 17:24
 * @description: TODO
 * GOOD LUCK!
 */
@SpringBootApplication
public class ApplicationRun {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationRun.class, args);
    }
}

4.1 创建一个Controller

package com.probuing.self.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wangxin
 * @date 2020/1/11 17:26
 * @description: TODO
 * GOOD LUCK!
 */
@RestController
public class HelloController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String helloController() {
        return "hello,SpringBoot";
    }
}

@RestController 包含@Controller 还有@ResponseBody
返回的就是json数据

  1. 启动测试


    启动
  • 启动测试后我们可以看到监听的端口(红框内)
  1. 访问Controller
    http://localhost:8080/hello

Springboot配置文件

4.1 配置文件介绍

properties:键值对配置
yml:可以跨应用
yaml:和yml一样
yml和yaml比properties强大的是可以在配置文件中定义一个数组或集合

server:
  port:8082
  • 前缀需要两个或多个空格,不能使用制表符
  • 不同等级用:隔开
  • 冒号之后如果有值,那么冒号和值之间至少有一个空格,不能紧贴着

配置文件优先级

  • properties->yml->yaml
  • 优先级:properties大于yml yum大于yaml

使用配置文件

  • yml文件内容 applicaiton.yml
server:
  port:8090

# 常量
name: 和平精英

# 对象
game:
  name: wow
  age: 10
  
# 数组
games: 
  - wow
  - cod
  - ps4

使用@Value读取配置文件

  • HelloController.java
package com.probuing.sb_config.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;
import java.util.Map;

/**
 * @author wangxin
 * @date 2020/1/11 17:48
 * @description: TODO
 * GOOD LUCK!
 */
@RestController
public class ConfigController {

    @Value("$(name)")
    private String name;

    //定义对象属性
    @Value("$(game.name)")
    private String gameName;

    //数组属性

    @Value("$(games[2])")
    private String getArrEl;
    @RequestMapping(value = "/config")
    public Map configMap() {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("name", name);
        map.put("game_name", gameName);
        map.put("getArrEl", getArrEl);
        return map;
    }
}

  • 启动类
/**
 * @author wangxin
 * @date 2020/1/11 17:58
 * @description: TODO
 * GOOD LUCK!
 */
@SpringBootApplication
public class ApplicationRun {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationRun.class, args);
    }
}

Application启动类要放在最外侧,要在所有的子包外面
Spring-boot 会自动加载启动类所在包下及其子包下的所有组件

  • 输出

game_name "wow"
name "和平精英"
getArrEl "ps4"

Environment获取配置文件信息

  • 注入Environment
    @Autowired
    private Environment env;
  • 通过Environment.getProperty获取配置文件信息
 @RequestMapping(value = "/config", method = RequestMethod.GET)
    public Map configMap() {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("name", name);
        map.put("game_name", gameName);
        map.put("getArrEl", getArrEl);
        return map;
    }

@ConfigurationProperties注解

  • Springboot官方使用的配置server:port
  1. 创建配置类
    Game.java
package com.probuing.sb_config.configbean;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @author wangxin
 * @date 2020/1/11 18:45
 * @description: TODO
 * GOOD LUCK!
 * Game配置类
 */
@Configuration
@ConfigurationProperties(prefix = "game")
@Data
public class GameConfig {
    private String name;
    private String age;

}

  • 使用配置类
 //配置类注入
    @Autowired
    private GameConfig gameConfig;
    @RequestMapping(value = "/configConfig")
    public String configureConfig() {
        String config = gameConfig.getName() + gameConfig.getAge();
        return config;
    }

注解解释

SpringBoot 自动配置的原理

我们了解了SpringBoot能够使得无比繁杂的工程变的简单,并且让很多繁杂的配置都消失了,我们来探究一下Spring是如何做到的
我们先从SpringBoot的启动类开始:
Spring的启动类中包括@SpringBootApplication 注解,和SpringApplication.run方法
我们跟进@SpringBootApplication注解中


image.png

我们看到这里重点的注解有三个:
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

我们继续看@SpringBootConfiguration源码

image.png

在这个源码中 我们看到了@Configuration注解,这个注解的作用就是声明当前类是一个配置类,然后Spring会自动扫描到添加了@Configuration的类,会读取其中的配置信息。@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类,项目中只能有一个。 @EnableAutoConfiguration这个注解的作用是告诉SpringBoot基于所添加的依赖,去了解如何配置Spring。就是这个注解帮我们完成了默认的配置,所以,我们使用SpringBoot构建一个项目,只需要引入所需框架的依赖,默认配置就可以交给SpringBoot处理了 比如我们添加了spring-boot-start-web`,而这个启动器中帮我们添加了tomcat、SpringMVC的依赖,此时Spring自动配置就知道需要开发一个web应用,然后就完成了SpringMVC的配置了
SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置,这些配置是否生效,取决于我们是否引入了对应库所需的依赖,如果有所需的对应的依赖那么默认配置就会生效。
所以,我们使用SpringBoot构建一个项目,只需要引入所需框架的依赖,配置就可以交给SpringBoot处理了,如果不希望使用默认配置,则可以通过自定义配置进行配置

@ComponentScan 这个是配置组件扫描的指令,提供了类似与<context:component-scan>标签的作用

image.png

这里看到通过basePackageClasses属性来指定要扫描的包,而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类,因此扫描的包是该类所在包及其子包,因此,一般启动类会放在一个比较前的包目录中

SpringBoot默认配置原理

在SpringApplication类构建的时候,我们可以看到这样一段初始化代码


image.png

进入setInitializers中


image.png

这里可以看到 通过SpringFactoriesLoader.loadFactoryNames(type, classLoader)加载一些FactoryName,然后利用createSpringFactoiesInstance将这些加载到的类名进行实例化
然后继续跟进loadFactoryNames方法:
image.png

可以看到利用类加载器加载某个文件:

    public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

我们可以发现SpringBoot会在初始化的时候,加载所有classpath:META-INF/spring.factories文件,包括jar包当中。我们看到在Spring的一个依赖包:spring-boot-autoconfigure中,就可以看到这样的文件spring.factories
以后我们引入的任何第三方容器,只要实现自动配置,都会有类似的文件

自动配置总结

SprongBoot为我们提供了默认配置,而默认配置生效的步骤:

  1. @EnableAutoConfiguration注解会去寻找META-INF/spring.factories文件,读取其中以EnableAutoConfiguration为key的所有类的名称,这些类就是提前写好的自动配置类
  2. 这些配置类都声明了@Configuration注解,并且通过@Bean注解提前配置了我们所需要的一切实例。完成自动配置
  3. 会有@Conditionalon注解,来决定配置是否会生效,如果我们自己配置了相关Bean,那么就会覆盖默认的自动配置的Bean
  4. 我们还可以通过配置application.properties文件,来覆盖自动配置中的属性
  • 启动器:
    我们如果不想配置,只需要引入依赖即可,而依赖的版本我们也无需关心,只要引入了SpringBoot提供的starter,就会自动管理依赖及版本了
  • 全局配置:
    SpringBoot的默认配置,都会读取默认属性,这些属性可以通过自定义application.properties文件来进行覆盖。这样虽然使用的还是默认配置,但是配置中的值以及改成了我们自定义的
    当我们需要自定义属性时,就需要覆盖application.properties指定key来覆盖

SpringBoot实战

整合Mybatis

引入依赖

  • pom.xml
<?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">
    <parent>
        <artifactId>SpringBoot</artifactId>
        <groupId>com.probuing</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>springboot_mybatis</artifactId>
    <dependencies>
        <!--起步依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--jdbc应用于事务管理-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

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

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

</project>
  • 启动类 SpringBootMybatisRunner.java
/**
 * @author wangxin
 * @date 2020/1/11 20:27
 * @description: TODO
 * GOOD LUCK!
 */
@SpringBootApplication
public class SpringBootMybatisRunner {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootMybatisRunner.class, args);
    }
}
  • 数据库表
SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_name` varchar(100) DEFAULT NULL COMMENT '用户名',
  `password` varchar(100) DEFAULT NULL COMMENT '密码',
  `name` varchar(100) DEFAULT NULL COMMENT '姓名',
  `age` int(10) DEFAULT NULL COMMENT '年龄',
  `sex` tinyint(1) DEFAULT NULL COMMENT '性别,1男性,2女性',
  `birthday` date DEFAULT NULL COMMENT '出生日期',
  `note` varchar(255) DEFAULT NULL COMMENT '备注',
  `created` datetime DEFAULT NULL COMMENT '创建时间',
  `updated` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`user_name`)
) ENGINE=InnoDB AUTO_INCREMENT=13 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES ('1', 'zhangsan1', '1234567', '张三', '25', '1', '1964-08-08', '张三同学在学Java', '2014-09-19 16:56:04', '2014-09-21 11:24:59');
INSERT INTO `tb_user` VALUES ('2', 'lisi11', '123456777', '李四', '21', '1', '1995-01-01', '李四同学在传智学Java', '2014-09-19 16:56:04', '2014-09-19 16:56:04');
INSERT INTO `tb_user` VALUES ('3', 'wangwu', '123456', '王五', '22', '1', '1994-01-01', '王五同学在学php', '2014-09-19 16:56:04', '2014-09-19 16:56:04');
INSERT INTO `tb_user` VALUES ('4', 'zhangwei', '123456', '张伟', '20', '1', '1996-09-01', '张伟同学在传智播客学Java', '2014-09-19 16:56:04', '2014-09-19 16:56:04');
INSERT INTO `tb_user` VALUES ('5', 'lina', '123456', '李娜', '28', '0', '1988-01-01', '李娜同学在传智播客学Java', '2014-09-19 16:56:04', '2014-09-19 16:56:04');
INSERT INTO `tb_user` VALUES ('6', 'lilei', '123456', '李磊', '23', '1', '1993-08-08', '李磊同学在传智播客学Java', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('7', 'hanmeimei', '123456', '韩梅梅', '24', '0', '1992-08-08', '韩梅梅同学在传智播客学php', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('8', 'liuyan', '123456', '柳岩', '21', '0', '1995-08-08', '柳岩同学在传智播客学表演', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('9', 'liuyifei', '123456', '刘亦菲', '18', '0', '1998-08-08', '刘亦菲同学在传智播客学唱歌', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('10', 'fanbingbing', '123456', '范冰冰', '25', '0', '1991-08-08', '范冰冰同学在传智播客学表演', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('11', 'zhengshuang', '123456', '郑爽', '23', '0', '1993-08-08', '郑爽同学在传智播客学习如何装纯', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
INSERT INTO `tb_user` VALUES ('12', 'tangyan', '123456', '唐嫣', '26', '0', '1990-08-08', '郑爽同学在传智播客学习如何耍酷', '2014-09-20 11:41:15', '2014-09-20 11:41:15');
  • 实体类 User.java
@Data
public class User {

    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private String note;
    private Date created;
    private Date updated;
}
  • dao层
public interface IUserDao {

    //根据id进行查询
    User findById(Long id);
}

  • 映射文件 mapper.xml


    image.png

    这里mapper的路径为自定义路径

<?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.probuing.sb.dao.IUserDao">

    <resultMap id="baseResultMap" type="User">
        <id column="id" property="id"></id>
        <result column="user_name" property="userName"></result>
        <result column="password" property="password"></result>
        <result column="name" property="name"></result>
        <result column="age" property="age"></result>
        <result column="sex" property="sex"></result>
        <result column="birthday" property="birthday"></result>
        <result column="note" property="note"></result>
        <result column="created" property="created"></result>
        <result column="updated" property="updated"></result>
    </resultMap>
    <select id="findById" parameterType="long" resultMap="baseResultMap">
        SELECT * FROM tb_user WHERE id = #{id}
    </select>
</mapper>
  • 配置文件application.yml

# 服务器地址
server:
  port: 8099
#数据库连接:
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: xml123xml

#mybatis扫描:
mybatis:
  mapper-locations: classpath:mappers/*.xml
  type-aliases-package: com.probuing.sb.domain
  • service层
    IUserService.java
public interface UserService {

    User findById(Long id);
}

实现类
IUserServiceImpl.java

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserDao userDao;

    @Override
    public User findById(Long id) {
        return userDao.findById(id);
    }
}
  • Controller
@RestController
public class UserController {

    @Autowired
    private IUserService userService;
    @RequestMapping(value = "/toUpdate/{id}")
    public User toUpdate(@PathVariable Long id) {//@PathVariable 表示取路径上的变量
        return userService.findById(id);
    }
}
  • 启动类 启动时需要扫描dao
@SpringBootApplication
@MapperScan("cn.itcast.dao")   //扫描dao
public class MybatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisApplication.class, args);
    }
}

注意

  • 映射文件的路径和接口IUserDao的路径不一致,在配置文件application.yml中,配置了mybatis的扫描
  • 在启动类中添加MapperScan扫描dao

整合通用Mapper

我们在开发中发现,dao层的技术,都是通用的,所以我们可以引入通用Mapper来实现减少映射文件mapper的编写

  • maven坐标 添加依赖
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        
        <!-- 通用mapper -->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
  • 配置文件
    application.yml
server:
  port: 8091

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: xml123xml
  • 实体类
    User.java
package com.probuing.sb_mapper.domain;

import lombok.Data;

import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Date;

@Data
@Table(name = "tb_user")
public class User {
    @Id
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private String note;
    private Date created;
    private Date updated;
}

注意
实体类中:

  • 要有表对应 使用@Table(name=表明)指定实体类对应的表名
  • 实体类中要有主键对应,使用@Id定义在属性上表明定义的属性映射主键
  • dao层
    创建一个空的Dao接口 继承Mapper
    注意:这里导入的包是 tk.mybatis.mapper.common.Mapper
    IUserDao.java
public interface IUSerDao extends Mapper<User> {
}
  • service层
    IUserService.java
public interface IUserService {
    User findById(Long id);
}

实现类
UserServiceImpl.java

@Service
public class UserServiceImpl implements IUserService {
    //注入IUserDao
    @Autowired
    private IUSerDao iuSerDao;

    public User findById(Long id) {
        return iuSerDao.selectByPrimaryKey(id);
    }
}

注意
这里Service的实现类中的dao已经继承了各种dao方法 包括select update insert delete 和条件的example

  • Controller层
    UserController.java
@RestController
public class UserController {
    @Autowired
    private IUserService userService;

    //    @RequestMapping(value = "/findUser/{id}")
    @GetMapping(value = "/findUser/{id}")
    public User findUser(@PathVariable("id") Long id) {
        return userService.findById(id);
    }
}

注意
这里的Controller的RequestMapping中,写法:
@RequestMapping(value="/findUser/{id}",method=RequestMethod.GET)等价于
@GetMapping("/findUser/{id}")

  • 启动类(需要扫描dao)
    ApplicationMapperRunner.java
    注意
    这里的MapperScan引入的包一定是tk包下的
@SpringBootApplication
@MapperScan("com.probuing.dao")
public class ApplicationRunner {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationRunner.class, args);
    }
}

  • 测试
    通过Mapper自定义接口实现查询
    IUserDao.java
public interface IUSerDao extends Mapper<User> {
    @Select("SELECT * FROM tb_user where user_name = #{userName}")
    User selectByUserName(String userName);
}
  • 通过Example条件查询
 @Test
    public void findUserNameExample() {
        Example example = new Example(User.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("userName", "lina");
        List<User> list = userDao.selectByExample(example);
        for (User user : list) {
            System.out.println(user.toString());
        }
    }

SpringBoot整合mybatisPlus

Mybatis-Plus(简称MP)是一个 Mybatis 的增强工具,在 Mybatis 的基础上只做增强不做改变,为简化开发、提高效率而生

引入依赖

  • pom坐标
<?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>cn.itcast</groupId>
    <artifactId>springboot_plus</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.3.RELEASE</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--管理事务,@Transtional-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>


        <!-- mybatis plus -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.2</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>
</project>
  • 配置文件
    application.yml
server:
  port: 8092

#数据库连接:
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql:///springboot
    username: root
    password: xml123xml
  • 实体类
    User.java
package com.probuing.mp.domain;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

import java.util.Date;

/**
 * @author wangxin
 * @date 2020/1/12 00:19
 * @description: TODO
 * GOOD LUCK!
 */
@Data
@TableName(value = "tb_user")
public class User {

    @TableId(type = IdType.AUTO)//表示自增 UUID表示UUID
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private String note;
    private Date created;
    private Date updated;
}

注意
实体类中必须定义表名(TableName),定义主键(TableId)

  • dao层
    IUserDao.java
public interface IUserDao extends BaseMapper<User> {
}

注意
mybatisPlus提供的是BaseMapper

  • service层
    IUserService.java
@Service
public class UserServiceImpl implements IUserService {
    @Autowired
    private IUserDao userDao;
    public User findById(Long id) {
        return userDao.selectById(id);
    }
}

注意
MybatisPlus 提供的是selectById

  • Controller
    UserController.java
@RestController
public class UserController {
    @Autowired
    private IUserService userService;

    @GetMapping(value = "/findById/{id}")
    public User findById(@PathVariable("id") Long id) {
        return userService.findById(id);
    }
}
  • 启动类扫描
    ApplicaitonMPRunner.java
@SpringBootApplication
@MapperScan("com.probuing.mp.dao")
public class ApplicationMPRunner {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationMPRunner.class, args);
    }
}

推荐阅读更多精彩内容

  • 参考引用: https://www.nosuchfield.com/2017/10/15/Spring-Boot-...
    沉沦2014阅读 127评论 0 1
  • springboot 概述 SpringBoot能够快速开发,简化部署,适用于微服务 参考嘟嘟大神SpringBo...
    一纸砚白阅读 3,968评论 2 20
  • SpringBoot 优势 SpringBoot是 Spring 家族下的一个新框架,其秉承了约定大于配置的理念,...
    末池桑阅读 81评论 0 1
  • “如何在SpringBoot中使用MyBatis。” MyBatis是一款优秀的数据库持久层框架,相比Hiber...
    刘某某_e250阅读 43评论 0 0
  • SpringBoot基础 学习目标: 能够理解Spring的优缺点 能够理解SpringBoot的特点 能够理解S...
    dwwl阅读 4,331评论 4 80