本文是Spring Boot学习笔记的第二天内容，介绍了Spring Boot的核心理念，包括简化配置、自动配置、可独立运行、快速启动等特性。详细讲解了如何从环境准备、起步依赖、变更JDK版本、创建引导类到编写入门程序，以及热部署的配置。同时，文章还简述了Spring Boot整合Spring Data JPA的过程，包括数据库配置、实体类、DAO接口、业务逻辑的实现。
Spring Boot
1. Spring Boot简介
Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的
轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级
Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。
虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。
第一阶段：xml配置
在Spring 1.x时代，使用Spring开发满眼都是xml配置的Bean，随着项目的扩大，我们需要把xml配置文件放到不同的配置文件里，那时需要频繁的在开发的类和配置文件之间进行切换
第二阶段：注解配置
在Spring 2.x 时代，随着JDK1.5带来的注解支持，Spring提供了声明Bean的注解（例如@Component、@Service），大大减少了配置量。主要使用的方式是应用的基本配置（如数据库配置）用xml，业务配置用注解
第三阶段：java配置
Spring 3.0 引入了基于 Java 的配置能力，这是一种类型安全的可重构配置方式，可以代替 XML。我们目前刚好处于这个时代，Spring4.x和Spring Boot都推荐使用Java配置。
所有这些配置都代表了开发时的损耗。 因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。除此之外，项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这难题实在太棘手。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。
Spring Boot 让这一切成为了过去。
Spring Boot 简化了基于Spring的应用开发，只需要“run”就能创建一个独立的、生产级别的Spring应用。Spring Boot为Spring平台及第三方库提供开箱即用的设置（提供默认设置），这样我们就可以简单的开始。多数Spring Boot应用只需要很少的Spring配置。
我们可以使用SpringBoot创建java应用，并使用java –jar 启动它，或者采用传统的war部署方式。
Spring Boot 主要目标是：
l 为所有 Spring 的开发提供一个从根本上更快的入门体验
l 开箱即用，但通过自己设置参数，即可快速摆脱这种方式。
l 提供了一些大型项目中常见的非功能性特性，如内嵌服务器、安全、指标，健康检测、外部化配置等
l 绝对没有代码生成，也无需 XML 配置。
2. Spring Boot 入门
2.1. 环境准备
数据库：MySQL
IDE：Eclipse Mars2
Spring-Boot：1.4.4
Maven： 3.3.3 （官方声明1.4.4版本需要Maven 3.2+）
本地仓库：需要使用资料中的仓库
2.2. 起步依赖
2.2.1. 创建一个Maven工程
2.2.2. 添加依赖
在pom.xml中添加依赖，效果如下
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.4.RELEASE</version>
</parent>
<groupId>cn.cnn.springboot</groupId>
<artifactId>cnn-springboot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
我们会惊奇地发现，我们的工程自动添加了好多好多jar 包，而这些jar 包正式我们做开发时需要导入的jar 包。
因为这些jar 包被我们刚才加入的spring-boot-starter-web 所引用了，所以添加spring-boot-starter-web后会自动把依赖传递过来。
2.3. 变更JDK版本
我们发现默认情况下工程的JDK版本是1.6，但是通常使用的是1.7的版本
修改JDK为1.7，需要在pom.xml中添加以下配置：
<properties>
<java.version>1.7</java.version>
</properties>
使用Maven更新工程后，就发现版本已经变成1.8了
注意：
虽然JDK1.6或者1.7都可以使用Spring-Boot，但Spring-Boot官方建议使用JDK1.8。要使用JDK1.8，首先必须要配置JDK1.8后，才可以使用上述方法设置。
2.4. 引导类
需要创建一个引导类：
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Demo {
public static void main(String[] args) {
SpringApplication.run(Demo.class, args);
}
}
这里多了一个@SpringBootApplication注解
@Configuration： 用于定义一个配置类
@EnableAutoConfiguration ：Spring Boot 会自动根据你jar 包的依赖来自动配置
项目。
@ComponentScan： 告诉Spring 哪个packages 的用注解标识的类会被spring
自动扫描并且装入bean 容器。
Banner
直接启动，控制台出现以下标识。
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.4.4.RELEASE)
这个标识是Spring启动标识，如果不想要，可以设置取消
import org.springframework.boot.Banner.Mode;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
// SpringApplication.run(Application.class, args);
SpringApplication application = new SpringApplication(Application.class);
application.setBannerMode(Mode.OFF);
application.run(args);
}
}
参考附录二的banner设置，可以通过修改配置文件制定自己的标识。
2.5. 入门程序
需求：使用Spring MVC实现Hello World输出
2.5.1. 原来的实现
我们现在开始使用spring MVC 框架，实现json 数据的输出。如果按照我们原来的做法，需要在web.xml 中添加一个DispatcherServlet 的配置，还需要添加一个spring的配置文件，配置文件如下配置
spring加入配置
<!-- controller注解扫描 -->
<context:component-scan base-package="cn.cnn.springboot.controller" />
<!-- 注解驱动 -->
<mvc:annotation-driven />
web.xml加入配置
<!-- 配置前端控制器 -->
<servlet>
<servlet-name> cnn-springboot</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/*.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name> cnn-springboot</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
还要编写Controller。。。
2.5.2. Spring-Boot的实现
我们不需要配置文件，直接编写Controller类即可
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class HelloWorldController {
@RequestMapping("info")
public String info() {
return "Hello world!";
}
}
@RestController注解:其实就是@Controller和@ResponseBody注解加在一起
启动方式一：启动之前编写的引导类即可
启动方式二：使用Maven命令spring-boot:run执行即可
选择 Maven Build
在浏览器地址栏输入http://localhost:8080/info 即可看到运行结果
2.6. 热部署
我们在开发中反复修改类、页面等资源，每次修改后都是需要重新启动才生效，这样每次启动都很麻烦，浪费了大量的时间。
能不能在我修改代码后不重启就能生效呢？可以，由于Spring Boot应用只是普通的Java应用，所以JVM热交换（hot-swapping）也能开箱即用。不过JVM热交换能替换的字节码有限制，想要更彻底的解决方案可以使用Spring Loaded项目或JRebel。 spring-boot-devtools 模块也支持应用快速重启(restart)。
我们只需要在pom.xml加入如下配置即可
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
</dependency>
3. SpringBoot整合
3.1. 整合Spring Data JPA
3.1.1. 需求
使用Spring Boot + Spring MVC + Spring Data JPA + EasyUI 框架组合实现部门列表查询，效果如下：
3.1.2. 环境准备
3.1.2.1. 导入数据库表
在MySQL数据库执行以下语句
DROP TABLE IF EXISTS `user`;
CREATE TABLE `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 '姓名',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
INSERT INTO `user` VALUES ('1', 'zhangsan', '123456', '张三');
INSERT INTO `user` VALUES ('2', 'lisi', '123456', '李四');
INSERT INTO `user` VALUES ('3', 'wangwu', '123456', '王五');
INSERT INTO `user` VALUES ('4', 'zhangwei', '123456', '张伟');
INSERT INTO `user` VALUES ('5', 'lina', '123456', '李娜');
INSERT INTO `user` VALUES ('6', 'lilei', '123456', '李磊');
3.1.2.2. 创建Maven工程
cnn-info(打jar包)，在pom.xml中进行如下配置
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.4.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
<version>1.4.4.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
3.1.2.3. 加入Spring-Boot配置文件
在src/main/resources 下添加application.properties 配置文件，内容如下：
#DB Configuration:
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/taotao
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
此文件用于覆盖Spring Boot的默认配置，完整的配置信息参考“附录2”
3.1.3. 后端实现
3.1.3.1. 创建实体类
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class User {
@Id
private Long id;
private String userName;
private String password;
private String name;
//添加 get 和set 方法
}
3.1.3.2. 创建DAO接口
import org.springframework.data.jpa.repository.JpaRepository;
import cn.cnn.info.pojo.User;
public interface UserDao extends JpaRepository<User, Long> {
}
3.1.3.3. 创建业务逻辑接口
import java.util.List;
import cn.cnn.info.pojo.User;
public interface UserService {
List<User> findAll();
}
3.1.3.4. 创建业务逻辑实现类
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import cn.cnn.info.dao.UserDao;
import cn.cnn.info.pojo.User;
import cn.cnn.info.service.UserService;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
@Override
public List<User> findAll() {
List<User> list = this.userDao.findAll();
return list;
}
}
3.1.3.5. 创建Controller
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import cn.cnn.info.pojo.User;
import cn.cnn.info.service.UserService;
@RestController
@RequestMapping("user")
public class UserControlelr {
@Autowired
private UserService userService;
@RequestMapping("list")
public List<User> queryUserAll() {
List<User> list = this.userService.findAll();
return list;
}
}
3.1.3.6. 创建引导类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
运行引导类Application，打开浏览器输入http://127.0.0.1:8080/user/list
3.1.4. 前端实现
把资料中的static文件夹，拷贝到src/main/resources路径下
浏览器地址栏输入：http://127.0.0.1:8080/user.html，效果如下
运行引导类Application
3.2. 整合MyBatis
3.2.1. 简单整合
3.2.1.1. 加入依赖
在pom.xml中加入以下依赖
<!-- SpringBoot的Mybatis启动器 -->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
3.2.1.2. 编写Mapper
和之前的方式一样，只是多了两个注解
@Mapper：声明Mapper接口
@Select：声明这个接口所需要使用的sql，当然，有查询的注解，肯定就有增删改的注解。
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import cn.cnn.info.pojo.User;
@Mapper
public interface UserMapper {
@Select("select * from user where name like '%${value}%'")
public List<User> queryUserByName(String name);
}
3.2.1.3. 编写Service和Controller
添加Service调用Mapper
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
@Autowired
private UserMapper userMapper;
@Override
public List<User> findAll() {
List<User> list = this.userDao.findAll();
return list;
}
@Override
public List<User> queryUserByName(String name) {
List<User> list = this.userMapper.queryUserByName(name);
return list;
}
}
修改Controller
@RestController
@RequestMapping("user")
public class UserControlelr {
@Autowired
private UserService userService;
@RequestMapping("list")
public List<User> queryUserAll() {
List<User> list = this.userService.findAll();
return list;
}
@RequestMapping("list/{name}")
public List<User> queryUserAll(@PathVariable String name) {
List<User> list = this.userService.queryUserByName(name);
return list;
}
}
3.2.1.4. 测试
浏览器地址栏输入：http://127.0.0.1:8080/user/list/张
显示效果：
3.2.2. 整合通用Mapper和分页助手
以上所有的配置都是使用的默认配置，我们只需要专注java代码的开发即可，不需要加入配置文件了。
但并不是所有得场景都是简单的业务，有时候业务复杂，需要我们加入自定义的配置文件；有时候需要载入例如分页助手这样的插件，辅助开发，所以我们也需要了解如何加载这些配置。
3.2.2.1. 加入依赖
我们需要加入通用Mapper和分页插件，所以需要在pom.xml加入以下依赖
<!-- 通用Mapper -->
<dependency>
<groupId>com.github.abel533</groupId>
<artifactId>mapper</artifactId>
<version>2.3.4</version>
</dependency>
<!-- 分页助手 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>3.7.5</version>
</dependency>
<dependency>
<groupId>com.github.jsqlparser</groupId>
<artifactId>jsqlparser</artifactId>
<version>0.9.1</version>
</dependency>
3.2.2.2. 修改配置文件
在application.properties添加配置
#spring集成Mybatis环境
#pojo别名扫描包
mybatis.type-aliases-package=cn.cnn.info.pojo
#加载Mybatis核心配置文件
mybatis.mapper-locations=classpath:mapper/*Mapper.xml
mybatis.config-location=classpath:mybatis/SqlMapConfig.xml
#配置连接池，还需要在pom.xml中加入该连接池的依赖
#spring.datasource.type=com.jolbox.bonecp.BoneCPDataSource
在src\main\resources\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.cnn.info.dao.UserMapper">
<select id="queryAll" resultType="user">
select * from user
</select>
</mapper>
在src\main\resources\mybatis加入SqlMapConfig.xml配置文件，用以加载通用Mapper和分页助手
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 分页助手 -->
<plugins>
<plugin interceptor="com.github.pagehelper.PageHelper">
<property name="dialect" value="mysql" />
<!-- 该参数默认为false -->
<!-- 设置为true时，使用RowBounds分页会进行count查询 -->
<property name="rowBoundsWithCount" value="true" />
</plugin>
<!-- 通用Mapper -->
<plugin interceptor="com.github.abel533.mapperhelper.MapperInterceptor">
<!--主键自增回写方法,默认值MYSQL,详细说明请看文档 -->
<property name="IDENTITY" value="MYSQL" />
<!--通用Mapper接口，多个通用接口用逗号隔开 -->
<property name="mappers" value="com.github.abel533.mapper.Mapper" />
</plugin>
</plugins>
</configuration>
3.2.2.3. 编写Mapper
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import cn.cnn.info.pojo.User;
//extends com.github.abel533.mapper.Mapper<User>:需要继承通用Mapper
@Mapper
public interface UserMapper extends com.github.abel533.mapper.Mapper<User> {
@Select("select * from user where name like '%${value}%'")
public List<User> queryUserByName(String name);
// 使用UserMapper.xml配置文件
public List<User> queryAll();
}
3.2.2.4. 编写Service和Controller
Service编写
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.github.pagehelper.PageHelper;
import cn.cnn.info.dao.UserDao;
import cn.cnn.info.dao.UserMapper;
import cn.cnn.info.pojo.User;
import cn.cnn.info.service.UserService;
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserDao userDao;
@Autowired
private UserMapper userMapper;
@Override
public List<User> findAll() {
List<User> list = this.userDao.findAll();
return list;
}
@Override
public List<User> queryUserByName(String name) {
List<User> list = this.userMapper.queryUserByName(name);
return list;
}
// 调用使用UserMapper.xml的Mapper
@Override
public List<User> queryAll() {
List<User> list = this.userMapper.queryAll();
return list;
}
// 使用通用Mapper和分页助手
@Override
public List<User> queryUserByPage(Integer page, Integer rows) {
// 设置分页
PageHelper.startPage(page, rows);
// 使用通用Mapper的方法进行查询所有数据
List<User> list = this.userMapper.select(null);
return list;
}
}
Controller编写
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import cn.cnn.info.pojo.User;
import cn.cnn.info.service.UserService;
@RestController
@RequestMapping("user")
public class UserControlelr {
@Autowired
private UserService userService;
@RequestMapping("list")
public List<User> queryUserAll() {
List<User> list = this.userService.findAll();
return list;
}
@RequestMapping("list/{name}")
public List<User> queryUserAll(@PathVariable String name) {
List<User> list = this.userService.queryUserByName(name);
return list;
}
@RequestMapping("list/query")
public List<User> queryUserAll2() {
List<User> list = this.userService.queryAll();
return list;
}
@RequestMapping("list/{page}/{rows}")
public List<User> queryUserAll(@PathVariable Integer page, @PathVariable Integer rows) {
List<User> list = this.userService.queryUserByPage(page, rows);
return list;
}
}
3.2.2.5. 测试
测试使用UserMapper.xml
浏览器地址栏输入：http://127.0.0.1:8080/user/list/query
测试使用通用Mapper和分页助手
浏览器地址栏输入：http://127.0.0.1:8080/user/list/2/2
3.3. 整合Redis
3.3.1. 注解方式实现添加缓存
需求：基于上例代码，将列表数据缓存到Redis
3.3.1.1. 加入依赖
在pom.xml加入依赖
<!-- 配置使用redis启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>
3.3.1.2. 修改引导类
修改开启缓存，添加注解@EnableCaching
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
3.3.1.3. 设置实现序列化接口
需要修改实体，让实体实现序列化接口
@Entity
public class User implements Serializable {
@Id
private Long id;
private String userName;
private String password;
private String name;
。。。。。。
}
3.3.1.4. 实现添加/删除缓存
修改UserServiceImpl，添加@Cacheable注解实现缓存添加
@Override
@Cacheable(value = "userCache", key = "'user.findAll'")
public List<User> findAll() {
System.out.println("从Mysql中查询");
List<User> list = this.userDao.findAll();
return list;
}
@Override
@CacheEvict(value = "userCache", key = "'user.findAll'")
public List<User> queryUserByName(String name) {
System.out.println("缓存清理了！");
List<User> list = this.userMapper.queryUserByName(name);
return list;
}
这样设置完成后，执行findAll()方法就会使用缓存，如果缓存没有就添加缓存，而queryUserByName(String name)方法则是删除缓存
@Cacheable：添加/使用缓存
@CacheEvict：删除缓存
参数value是缓存的名字，在执行的时候，会找叫这个名字的缓存使用/删除
参数key默认情况下是空串””,是Spring的一种表达式语言SpEL，我们这里可以随意指定，但是需要注意一定要加单引号
3.3.2. redis的深入使用
3.3.2.1. 直接操作redis
redis除了作为缓存使用，还有很多其他的作用，例如利用redis的单线程获取唯一数，例如使用redis为单点登录系统存储用户登录信息等，我们就需要直接操作redis。
官网提供了三种接口RedisConnectionFactory, StringRedisTemplate 和 RedisTemplate，我们可以直接注入或者自己实现其他的实现类，来直接操作redis。我们这里使用RedisTemplate来操作Redis。
如下所示，我们只需要直接注入RedisTemplate即可使用以下方法操作redis的五种不同的数据类型
测试：
@Autowired
private RedisTemplate<String, String> redisTemplate;
@Override
@CacheEvict(value = "userCache", key = "'user.findAll'")
public List<User> queryUserByName(String name) {
// 保存数据
this.redisTemplate.boundValueOps("redis").set("Hello redis !");
// 设置有效时间为100秒
this.redisTemplate.boundValueOps("redis").expire(100l, TimeUnit.SECONDS);
// 给value每次执行加一操作
this.redisTemplate.boundValueOps("count").increment(1l);
System.out.println("缓存清理了！");
List<User> list = this.userMapper.queryUserByName(name);
return list;
}
3.3.2.2. 设置redis连接属性
redis单机版
redis启动器默认情况下会找本地的redis服务，端口号默认是6379如果需要访问其他服务器的redis，则需要在application.properties中进行如下配置：
#Redis
spring.redis.host=192.168.37.161
spring.redis.port=6379
这表示会去找ip为192.168.37.161和端口为6379的服务
redis集群版
#Redis
#spring.redis.host=192.168.37.161
#spring.redis.port=6379
#Redis Cluster
spring.redis.cluster.nodes=192.168.37.161:7001,192.168.37.161:7002,192.168.37.161:7003,192.168.37.161:7004,192.168.37.161:7005,192.168.37.161:7006
切换到集群版只需要做以上配置，配置集群版节点信息，注释掉单机版信息
3.4. 整合ActiveMQ
3.4.1. 加入依赖
在pom.xml中加入以下配置
<!-- 配置ActiveMQ启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-activemq</artifactId>
</dependency>
3.4.2. 创建队列
在引导类中添加以下方法，设置队列
@SpringBootApplication
@EnableCaching
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Bean
public Queue queue() {
return new ActiveMQQueue("cnn.queue");
}
}
3.4.3. 发送消息
编写Controller，发送消息
import javax.jms.Destination;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("queue")
public class QueueController {
//注入发送消息的对象
@Autowired
private JmsTemplate jmsTemplate;
//注入消息队列
@Autowired
private Destination destination;
//编写发送消息的方法
@RequestMapping("send/{message}")
public String send(@PathVariable String message) {
this.jmsTemplate.convertAndSend(destination, message);
return "消息发送成功!消息内容：" + message;
}
}
3.4.4. 接收消息
编写bean，加入@Component注解让spring管理这个bean，作为接收消息的消费者
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;
@Component
public class Consumer {
// 接受消息方法
@JmsListener(destination = "cnn.queue")
public void readMessage(String text) {
System.out.println("接受到的消息是：" + text);
}
}
测试：
启动服务后，在浏览器执行http://127.0.0.1:8080/queue/send/发消息了11
即可看到消息发送成功
同时可以在控制台看到打印信息
我们没有安装ActiveMQ，为什么可以使用？因为Spring Boot 内置了ActiveMQ 的服务，所以我们不用单独启动也可以实现消息的发送和接收。
3.4.5. 使用外部服务
首先确认有一台外部ActiveMQ服务可以使用
在application.properties中加入以下配置
#ActiveMQ
spring.activemq.broker-url=tcp://192.168.37.161:61616
这样就加入了ActiveMQ服务的地址
3.5. 整合junit
3.5.1. 加入依赖
在pom.xml中加入测试依赖
<!-- 配置测试启动器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
3.5.2. 编写测试类
import javax.jms.Destination;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.spr
最低0.47元/天 解锁文章
扫一扫
8330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
