SpringBoot初学笔记

最新推荐文章于 2023-03-15 21:42:27 发布

原创最新推荐文章于 2023-03-15 21:42:27 发布 · 320 阅读

0 ·

CC 4.0 BY-SA版权

学习笔记专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了SpringBoot的核心功能，包括起步依赖和自动配置，并逐步讲解了SpringBoot的快速入门，如环境搭建、编写引导类和Controller。此外，还深入探讨了SpringBoot的配置文件类型和作用，以及如何集成Mybatis、Junit、SpringDataJPA和Redis，是SpringBoot初学者的实用教程。

SpringBoot

1.SpringBoot核心功能
- 1.1 起步依赖
- 1.2 自动配置
2.SpringBoot快速入门
3.SpringBoot配置文件的类型和作用
4. SpringBoot集成

1.SpringBoot核心功能

1.1 起步依赖

不需要自己导入大量坐标，只要导入打包后的坐标配置进去就行，打包后的坐标就是起步依赖

1.2 自动配置

SpringBoot的自动配置是一个运行时（更准确的说，是应用程序启动时）的过程，考虑了众多因素，才决定Spring配置应该用哪个，不该用哪个，该过程是Spring自动完成的。

2.SpringBoot快速入门

2.1 环境搭建

2.1.1 创建Maven工程

2.1.2 添加SpringBoot的起步依赖

SpringBoot要求，项目要继承SpringBoot的起步依赖Spring-boot-start-parent

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

SpringBoot要集成SpringMVC进行Controller的开发，所以项目要导入web的启动依赖

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

2.1.3 编写SpringBoot的引导类

编写完后，运行main方法即可用localhost:8080测试启动是否成功

@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class);
    }
}

2.1.4 编写Controller

@ResponseBody ：将返回值放入Body内，默认是解析为路径

@Controller
public class QuickController {
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "hello springboot";
    }
}

2.1.5 测试

运行main方法即可用localhost:8080测试启动是否成功

2.2 热部署

添加一个功能坐标

<dependency>
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-devtools</artifactId>
</dependency>

2.2.1 Idea热部署设置

idea默认不支持热部署，需要设置
在这里插入图片描述

3.SpringBoot配置文件的类型和作用

3.1 概念

SpringBoot是基于约定的，所以很多配置都有默认值，如果想使用自己的配置替换默认配置的话，就可以使用application.properties和**application.yml(application.yaml)**进行配置。
SpringBoot默认会从Resources目录下加载这些配置文件

3.2 application.yml配置

3.2.1 普通语法

语法：key: value
注：value之前有一个空格
示例：

name: xkm

3.2.2 对象的配置语法

server.port举例，所有的层级关系.变成空格

person: 
	name: xkm
	age: 18
	addr: beijing

更改端口号

server: 
	port: 8081

3.2.3 行类对象配置语法

person: {name: xkm,age: 18,addr: beijin}

3.2.4 配置数据，集合语法

字符串集合：

city: 
  - beijing
  - shanghai
  - guangzhou
  - shenzhen

对象集合：

student:
  - name: xkm
   age: 18
  - name: mgdz
   age: 20

map配置:

map:
	key1: value1
	key2: value2

3.2 通过@Value映射数据

通过@Value获取值，如果是键值对直接用key
如果取对象内属性用. 如${student.name}

@Controller
public class QuickController {
    @Value("${name}")
    private String name;
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return name;
    }
}

3.3 通过@ConfiguraProperties映射数据

利用@ConfiguraProperties自动匹配到你想要的数据，但是要配置好get set方法

@Controller
@ConfigurationProperties(prefix = "person")
public class QuickController {
    private String name;
    private String age;
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return name+age;
    }

3.4 SpringBoot配置文件-configuration-processor

配置后，在application.yml中就会有提示

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

4. SpringBoot集成

4.1 集成Mybatis

4.1.1 添加Mybatis的起步依赖

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

4.1.2 添加数据库驱动坐标

 		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

4.1.4 添加数据库连接信息

#DB Configuration:
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

4.1.5 创建数据库user表

DROP TABLE IF EXISTS `user`; 
CREATE TABLE `user` ( 
`id` INT(11) NOT NULL AUTO_INCREMENT,
 `username` VARCHAR(50) DEFAULT NULL, 
 `password` VARCHAR(50) DEFAULT NULL,
  `name` VARCHAR(50) DEFAULT NULL, 
  PRIMARY KEY (`id`) ) 
  ENGINE=INNODB AUTO_INCREMENT=10 
  DEFAULT CHARSET=utf8;
   -- ---------------------------- -- Records of user -- ---------------------------- 
   INSERT INTO `user` VALUES ('1', 'zhangsan', '123', '张三'); 
   INSERT INTO `user` VALUES ('2', 'lisi', '123', '李四');

4.1.6 创建user实体类


public class User {
    // 主键
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;

4.1.7 编写Mapper

@Mapper
public interface UserMapper {
    public List<User> queryUserList();
}

4.1.8 配置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="xkm.example.mapper.UserMapper">
    <select id="queryUserList" resultType="User">
    select * from user
    </select>
</mapper>

4.1.9 在Springboot配置文件中配置Mybatis

#spring集成Mybatis环境
#pojo别名扫描包
mybatis.type-aliases-package=xkm.example.domain
#加载Mybatis映射文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml

4.1.10 编写Controller测试

@Controller
public class MyBatisController {
    @Autowired
    private UserMapper userMapper;

    @RequestMapping("/query")
    @ResponseBody
    public List<User> queryUserList(){
        List<User> users = userMapper.queryUserList();
        return users;
    }
}

4.2 集成Junit

4.2.1 添加Junit起步依赖

生成Springboot工程时会自动导入

		 <dependency> 
            <groupId>org.springframework.boot</groupId> 
            <artifactId>spring-boot-starter-test</artifactId> 
            <scope>test</scope> 
        </dependency>

4.2.2 测试代码

我发现idea在创建SpringBoot的project时就已经给我们创建好了test的环境，只需要我们导入我们要用的mapper就可以直接使用了

@SpringBootTest
class SpringbootMybatisApplicationTests {
    @Autowired
    private UserMapper userMapper;
    @Test
    void contextLoads() {
        List<User> users = userMapper.queryUserList();
        users.forEach(a-> System.out.println(a));
    }

}

4.3 集成SpringDataJPA

4.3.1 导入SpringDataJPA启动依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

4.3.2 添加数据库依赖

<dependency> 
<groupId>mysql</groupId> 
<artifactId>mysql-connector-java</artifactId>
 </dependency>

4.3.3 在SpringBoot的配置文件中添加数据库和JPA的配置

#DB Configuration:
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

#JPA Configuration:
spring.jpa.database=MySQL
spring.jpa.show-sql=true 
spring.jpa.generate-ddl=true 
spring.jpa.hibernate.ddl-auto=update
spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy

4.3.4 创建实体类

@Entity
public class User {
    @Id
    // 主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    // 用户名
    private String username;
    // 密码
    private String password;
    // 姓名
    private String name;

4.3.5 创建接口respository

public interface UserRepository extends JpaRepository<User,Long>{
    public List<User> findAll();
}

4.3.6 测试

@SpringBootTest
class SpringbootJpaApplicationTests {
    @Autowired
    private UserRepository userRepository;
    @Test
    void contextLoads() {
        List<User> all = userRepository.findAll();
        all.forEach(a-> System.out.println(a));
    }
}

4.4 集成Redis

4.4.1 导入Redis起步依赖

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

4.4.2 Spring配置文件配置redis的连接信息

#Redis 
spring.redis.host=127.0.0.1 
spring.redis.port=6379

4.4.3 测试代码

@SpringBootTest
class SpringbootJpaApplicationTests {
    @Autowired
    private UserRepository userRepository;
    @Autowired
    private RedisTemplate<String,String> redisTemplate;
    @Test
    void contextLoads() throws JsonProcessingException {
//      1.从redis中获得数据，数据的形式josn字符串
        String userListJson = redisTemplate.boundValueOps("user.findAll").get();
//      2.判断redis中是否存在数据
        if (userListJson==null){
//      3.不存在就从数据库查询，存在从redis获取
        List<User> all = userRepository.findAll();
//      4.将查询出的集合转换成Json字符串存入redis
        ObjectMapper mapper = new ObjectMapper();
        userListJson = mapper.writeValueAsString(all);
        redisTemplate.boundValueOps("user.findAll").set(userListJson);
            System.out.println("====数据库查询的数据======");
        }else{
            //        4.打印结果
            System.out.println("===从redis查询的数据===");
        }
        System.out.println(userListJson);
    }
}