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