SpringBoot(一)

2020-01-12 本文已影响0人 So_ProbuING

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);
    }

}

启动类分析

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

手动创建SpringBoot项目

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

image.png
引入spring父工程依赖

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

添加一个起步依赖(引入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的父工程已经对版本进行管理了

创建一个启动类

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数据

启动测试

启动

启动测试后我们可以看到监听的端口(红框内)

访问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

创建配置类
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为我们提供了默认配置，而默认配置生效的步骤：

@EnableAutoConfiguration注解会去寻找META-INF/spring.factories文件，读取其中以EnableAutoConfiguration为key的所有类的名称，这些类就是提前写好的自动配置类
这些配置类都声明了@Configuration注解，并且通过@Bean注解提前配置了我们所需要的一切实例。完成自动配置
会有@Conditionalon注解，来决定配置是否会生效，如果我们自己配置了相关Bean，那么就会覆盖默认的自动配置的Bean
我们还可以通过配置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);
    }
}

SpringBoot(一)

Springboot(一)

什么是SpringBoot

为什么要用SpringBoot

SpringBoot的特点

快速入门

快速创建SpringBoot项目

手动创建SpringBoot项目

Springboot配置文件

4.1 配置文件介绍

配置文件优先级

使用配置文件

使用@Value读取配置文件

Environment获取配置文件信息

@ConfigurationProperties注解

SpringBoot 自动配置的原理

SpringBoot默认配置原理

自动配置总结

SpringBoot实战

整合Mybatis

引入依赖

整合通用Mapper

SpringBoot整合mybatisPlus

引入依赖

猜你喜欢

热点阅读