Springboot整合mybatis和redis各种框架

SpringBoot的特点

• 为基于Spring的开发提供更快的入门体验
• 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
• 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
• SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式

SpringBoot快速入门

1. 创建Maven工程
   使用idea工具创建一个maven工程，该工程为普通的java工程即可
2. 添加SpringBoot的起步依赖
   SpringBoot要求，项目要继承SpringBoot的起步依赖spring-boot-starter-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>

3. 编写SpringBoot引导类

package cn.zhang;

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

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

4. 编写Controller

package cn.zhang.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
@Controller
public class QuickStartController {
@RequestMapping("/test")
@ResponseBody
public String test(){
	return "springboot入门成功";
	}
}

SpringBoot代码解析

@SpringBootApplication：标注SpringBoot的启动类，该注解具备多种功能（后面详细剖析）
SpringApplication.run(MySpringBootApplication.class) 代表运行SpringBoot的启动类，参数为SpringBoot启动类的字节码对象

SpringBoot工程热部署

在 pom.xml 中添加如下配置

<!--热部署配置-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>

注意：IDEA进行SpringBoot热部署失败原因
出现这种情况，并不是热部署配置问题，其根本原因是因为Intellij IEDA默认情况下不会自动编译，需要对IDEA进
行自动编译的设置，如下

然后 Shift+Ctrl+Alt+/，选择Registry

使用idea快速创建SpringBoot项目

通过idea快速创建的SpringBoot项目的pom.xml中已经导入了我们选择的web的起步依赖的坐标

springBoot的配置文件

SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用
application.properties或者application.yml（application.yaml）进行配置

yml配置文件的语法

• 配置普通数据
  语法： key: value

name: haohao

• 配置对象数据
  语法：
  key:
  key1: value1
  key2: value2
  或者：key: {key1: value1,key2: value2}

#记得value前写空格
person:
name: haohao
age: 31
addr: beijing
#或者
person: {name: hao,age: 20,addr: beijing}

• 配置数组（List、Set）数据
  语法：
  key:
  – value1
  – value2
  或者：
  key: [value1,value2]
  示例代码：

city:
- beijing
- tianjin
- shanghai
- chongqing
#或者
city: [beijing,tianjin,shanghai,chongqing]
#集合中的元素是对象形式
student:
- name: zhangsan
  age: 18
  score: 100
- name: lisi
  age: 28
  score: 88
- name: wangwu
  age: 38
  score: 90
  #注意value1与之间的 - 之间存在一个空格

SpringBoot配置信息的查询

文档url:https://docs.spring.io/spring-boot/docs/2.0.1.RELEASE/reference/htmlsingle/#common-application-properties
例如修改tomcat端口默认配置和添加虚拟路径

server.port=8888
server.servlet.context-path=demo

配置文件与配置类的属性映射方式

1. 使用注解@Value映射
   我们可以通过@Value注解将配置文件中的值映射到一个Spring管理的Bean的字段上
   application.properties配置如下

student.name=zhangsan
student.age=18

@Controller
public class StartSpringController {
    Value自动映射属性
    @Value("${student.name}")
    private String name;
    @Value("${student.age}")
    private Integer age;
    
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "hello springboot"+name+age;
    }
 }

2. 使用注解@ConfigurationProperties映射
   通过注解@ConfigurationProperties(prefix=“配置文件中的key的前缀”)可以将配置文件中的配置自动与实体进行映
   射

@Controller
//映射实体类对象
@ConfigurationProperties(prefix = "student")
public class StartSpringController {
   private Integer age;
    private String name;

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }    
    
    @RequestMapping("/quick")
    @ResponseBody
    public String quick(){
        return "hello springboot"+name+age;
    }
 }

SpringBoot与整合其他技术

SpringBoot整合Mybatis

添加Mybatis的起步依赖

<!--mybatis起步依赖-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>

添加数据库驱动坐标

<!-- MySQL连接驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

添加数据库连接信息
在application.properties中添加数据量的连接信息

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

编写实体bean

package cn.zhang.domain;

public class User {
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    private String name;
    private Double money;
}

编写Mapper
注意：@Mapper标记该类是一个mybatis的mapper接口，可以被spring boot自动扫描到spring上下文中

package cn.zhang.mapper;

import cn.zhang.domain.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

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

配置Mapper映射文件UserMapper.xml

<?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="cn.zhang.mapper.UserMapper">
    <select id="findUserList" resultType="user">
        select * from account
    </select>
</mapper>

在application.properties中添加mybatis的信息

#pojo别名扫描包
mybatis.type-aliases-package=cn.zhang.domain
#加载Mybatis映射文件
mybatis.mapper-locations=classpath*:*Mapper.xml

编写测试Controller

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

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

SpringBoot整合Junit

添加Junit的起步依赖

<!--测试的起步依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

编写测试类

package cn.zhang;

import cn.zhang.domain.User;
import cn.zhang.mapper.UserMapper;
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;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = MySpringBootApp.class)
public class TestMybatis {
    @Autowired
    UserMapper userMapper;

    @Test
    public void test(){
        List<User> userList = userMapper.findUserList();
        System.out.println(userList);
    }

}

SpringRunner继承自SpringJUnit4ClassRunner，使用哪一个Spring提供的测试测试引擎都可以
@SpringBootTest的属性指定的是引导类的字节码对象

SpringBoot整合Spring Data JPA

添加Spring Data JPA的起步依赖

<!-- springBoot JPA的起步依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

添加数据库驱动依赖

<!-- MySQL连接驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>

在application.properties中配置数据库和jpa的相关属性

#DB Configuration:
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/video?useUnicode=true&characterEncoding=utf8
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

创建实体配置实体

package cn.zhang.domain;

import javax.persistence.*;

@Entity
public class Account {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private Double money;

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }
}

编写UserRepository

package cn.zhang.repository;

import cn.zhang.domain.Account;
import cn.zhang.domain.User;
import org.springframework.data.jpa.repository.JpaRepository;

import java.util.List;

public interface UserRepository extends JpaRepository<Account,Integer> {
    public List<Account> findAll();

}

编写测试类

@RunWith(SpringRunner.class )
@SpringBootTest(classes =SpringbootJpaApplication.class )
public class JpaTest {
	@Autowired
	private UserRepository userRepository;
	@Test
	public void test(){
		List<Account> users = userRepository.findAll();
		System.out.println(users);
	}
}

如果是jdk9，执行报错如下

原因：jdk缺少相应的jar
解决方案：手动导入对应的maven坐标，如下

<!--jdk9需要导入如下坐标-->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.0</version>
</dependency>

如果按如上步骤运行还是报异常应该是版本问题，修改spring-boot-starter-parent版本为2.4.3而不是2.0.2release，如下

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
        <relativePath/> 
    </parent>

SpringBoot整合Redis

添加redis的起步依赖

<!-- 配置使用redis启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置redis的连接信息

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

注入RedisTemplate测试redis操作

@RunWith(SpringRunner.class )
@SpringBootTest(classes =SpringbootJpaApplication.class )
public class JpaTest {

    @Autowired
    UserRepository userRepository;

    @Autowired
    RedisTemplate<String,String> redisTemplate;

    @Test
    public void testJ() throws JsonProcessingException {
        //从redis缓存中获得指定的数据
        String userList=redisTemplate.boundValueOps("data").get();
        //如果redis中没有数据的话则从数据库获取
        if(userList==null){
            List<Account> list=userRepository.findAll();
            //转换成json存储到redis中
            ObjectMapper objectMapper=new ObjectMapper();
            userList=objectMapper.writeValueAsString(list);
            redisTemplate.boundValueOps("data").set(userList);
            System.out.println("===============从数据库获得数据===============");
        }else {
            System.out.println("===============从redis缓存中获得数据===============");
        }
        System.out.println(userList);

    }
}