微服务学习笔记（1）--springboot

Spring Boot HelloWorld

浏览器发送 hello 请求，服务器接受请求并处理，响应 Hello World 字符串；
1.  创建一个 maven 工程；（jar）
2.  导入 spring boot 相关的依赖

org.springframework.boot
spring‐boot‐starter‐parent
1.5.9.RELEASE



org.springframework.boot
spring‐boot‐starter‐web

3.  编写一个主程序；启动 Spring Boot 应用

/**
* @SpringBootApplication 来标注一个主程序类，说明这是一个 Spring Boot 应用
*/
@SpringBootApplication
public class HelloWorldMainApplication {
public static void main(String[] args) {
// Spring 应用启动起来
SpringApplication.run(HelloWorldMainApplication.class,args);
}
}

4.  编写相关的 Controller、Service

@Controller
public class HelloController {
@ResponseBody
@RequestMapping("/hello")
public String hello(){
return "Hello World!";
}
}

5.  运行主程序测试HelloWorldMainApplication

6.  简化部署

org.springframework.boot
spring‐boot‐maven‐plugin

将这个应用打成 jar 包，直接使用 java -jar 的命令进行执行；

通过maven的指令（我这是IDEA的）

然后我们可以通过 java -jar 的指令直接运行它。

然后我们还是可以直接通过浏览器访问：（截图和上面的一样的）

Hello World 探究
POM 文件

org.springframework.boot
spring‐boot‐starter‐parent
1.5.9.RELEASE

他的父项目是

org.springframework.boot
spring‐boot‐dependencies
1.5.9.RELEASE
../../spring‐boot‐dependencies

他来真正管理 Spring Boot 应用里面的所有依赖版本；
Spring Boot 的版本仲裁中心；
以后我们导入依赖默认是不需要写版本；（没有在 dependencies 里面管理的
依赖自然需要声明版本号）

2.  启动器

org.springframework.boot
spring‐boot‐starter‐web

spring-boot-starter-web：
spring-boot-starter：spring-boot 场景启动器；帮我们导入了 web 模块正常运行所依赖的组
件；
Spring Boot 将所有的功能场景都抽取出来，做成一个个的 starters（启动器），只需要在项目
里面引入这些 starter
相关场景的所有依赖都会导入进来。要用什么功能就导入什么场景的启动器

 主程序类，主入口类

1. @SpringBootApplication:
Spring Boot 应用标注在某个类上说明这个类是 SpringBoot 的主配置类，SpringBoot
就应该运行这个类的 main 方法来启动 SpringBoot 应用；

2.  @SpringBootConfiguration:Spring Boot 的配置类；
     标注在某个类上，表示这是一个 Spring Boot 的配置类；
3.  @Configuration:配置类上来标注这个注解；
     配置类 ----- 配置文件；配置类也是容器中的一个组件；@Component

4.  @EnableAutoConfiguration：开启自动配置功能；
     以前我们需要配置的东西，Spring Boot 帮我们自动配置；@EnableAutoConfiguration
    告诉 SpringBoot 开启自
    动配置功能；这样自动配置才能生效；

5.  @AutoConfigurationPackage：自动配置包
     @Import(AutoConfigurationPackages.Registrar.class)：Spring 的底层注解@Import，给容器中导入一个组件；导入的组件由
     AutoConfigurationPackages.Registrar.class；将主配置类（@SpringBootApplication 标注的类）的所在包及下面所有子包里面的所有
     组件扫描到 Spring 容器；
6.  @Import(EnableAutoConfigurationImportSelector.class)；
     给容器中导入组件？
    EnableAutoConfigurationImportSelector：导入哪些组件的选择器；
    将所有需要导入的组件以全类名的方式返回；这些组件就会被添加到容器中；
   会给容器中导入非常多的自动配置类（xxxAutoConfiguration）；就是给容器中导入这个
   场景需要的所有组件，
   并配置好这些组件；

使用 Spring Initializer 快速创建 Spring Boot 项目

IDEA：使用 Spring Initializer 快速创建项目
IDE 都支持使用 Spring 的项目创建向导快速创建一个 Spring Boot 项目；
选择我们需要的模块；向导会联网创建 Spring Boot 项目；
默认生成的 Spring Boot 项目；
主程序已经生成好了，我们只需要我们自己的逻辑
resources 文件夹中目录结构
static：保存所有的静态资源； js css images；
templates：保存所有的模板页面；（Spring Boot 默认 jar 包使用嵌入式的 Tomcat，默认不
支持 JSP 页面）；可以使用模板引擎（freemarker、thymeleaf，Swagger2等）；
application.properties：Spring Boot 应用的配置文件；可以修改一些默认设置；

springboot  的热部署

spring 为开发者提供了一个名为 spring-boot-devtools 的模块来使 Spring Boot 应用支
持热部署，提高开发者的开发效率，无需手动重启 Spring Boot 应用。

引入依赖

org.springframework.boot
spring-boot-devtools
true

修改 java 代码或者配置文件模板后可以通过 ctrl+f9 来实施热部署。(IDEA)

配置文件

SpringBoot 使用一个全局的配置文件，配置文件名是固定的；
•application.properties
•application.yml
配置文件的作用：修改 SpringBoot 自动配置的默认值；SpringBoot 在底层都给我们自动配置好；
YAML（YAML Ain't Markup Language）
YAML A Markup Language：是一个标记语言
YAML isn't Markup Language：不是一个标记语言；
标记语言：
以前的配置文件；大多都使用的是 xxxx.xml 文件；
YAML：以数据为中心，比 json、xml 等更适合做配置文件；

YAML 语法

1. 基本语法
k:(空格)v：表示一对键值对（空格必须有）；
以空格的缩进来控制层级关系；只要是左对齐的一列数据，都是同一个层级的

注意：属性和值也是大小写敏感；

2. 值的写法
字面量：普通的值（数字，字符串，布尔）
k: v：字面直接来写；
字符串默认不用加上单引号或者双引号；
""：双引号；不会转义字符串里面的特殊字符；特殊字符会作为本身想表示的意思
name: "zhangsan \n lisi"：输出；zhangsan 换行 lisi
''：单引号；会转义特殊字符，特殊字符最终只是一个普通的字符串数据
name: ‘zhangsan \n lisi’：输出；zhangsan \n lisi

3. 对象、Map（属性和值）（键值对）：
k: v：在下一行来写对象的属性和值的关系；注意缩进
对象还是 k: v 的方式

数组（List、Set）：
用- 值表示数组中的一个元素

配置文件值注入

下面要提供setter和getter方法的

测试，使用测试了测试：

我们可以导入配置文件处理器，以后编写配置就有提示了

org.springframework.boot
spring‐boot‐configuration‐processor
true

 properties的语法，不用多说吧，都是一样的使用

person.last-name=成吉思汗
person.age=${random.int(100)}
person.birthday=1029/12/12
person.boss=true
person.hello=luky
person.maps.key1=value1
person.maps.key2=value2
person.lists=cat,dog,annimal
person.dog.name=${person.hello}_dog
person.dog.age=${person.age}
[email protected]

 JavaBean

@Component
public class Person1 {
    @Value("${person.last-name}")
    private String lastName;

    @Value("#{12*3}")
    private int age;

    @Value("${person.boss}")
    private boolean boss;

    @Value("${person.birthday}")
    private Date birthday;

    private Map maps;
    @Value("${person.lists}")
    private List lists;

    private Dog dog;

    @Value("${person.hello}")
    private String hello;

    @Value("${person.email}")
    private String email;

    @Override
    public String toString() {
        return "Person{" +
                "lastName='" + lastName + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birthday=" + birthday +
                ", maps=" + maps +
                ", lists=" + lists +
                ", dog=" + dog +
                ", email=" + email +
                '}';
    }
}

测试

随机内容⽣成（application.properties）

# 随机字符串 1
random.string=${random.value} 2
# 随机int 3
random.number=${random.int} 4
# 随机long 5
random.long=${random.long} 6
# 1-20的随机数 7
random.b=${random.int[1,20]}

多环境配置
我们在开发应⽤时，通常⼀个项⽬会被部署到不同的环境中，⽐如：开发、测试、⽣产等。其中每个环境的数据库地址、服务器端⼝等等配置都会不同，对于多环境的配置，⼤部分构建⼯具或是框架解决的基本思路是⼀致的，通过配置多份不同环境的配置⽂件，再通过打包命令指定需要打包的内容之后进⾏区分打包，Spring Boot也提供了⽀持在Spring Boot中多环境配置⽂件名需要满⾜

application-{profile}.properties的格式，其中{profile}对应你的环境标识，⽐如：
application-dev.properties：开发环境
application-test.properties：测试环境
application-prod.properties：⽣产环境

⾄于哪个具体的配置⽂件会被加载，需要在application.properties⽂件中通过
spring.profiles.active属性来设置，其值对应 {profile}值。
⽐如： spring.profiles.active=dev 就会加载 application-dev.properties 配置⽂件中的内容

在dev, test, prod这三个⽂件均都设置不同的 server.port端⼝ 属性，如：dev环境设置为
8081，test环境设置为8082，prod环境设置为8083

application.properties中设置 spring.profiles.active=test，就是说默认以test环境设置

总结：
1.application.properties中配置通⽤内容，并设置spring.profiles.active=dev，以
开发环境为默认配置
2.application-{profile}.properties中配置各个环境不同的内容。

Spring boot 集成模板引擎实现web应⽤
静态资源访问
静态资源：js, css, html, 图⽚，⾳视频等
静态资源路径：是指系统可以直接访问的路径，且路径下的所有⽂件均可被⽤户直接读取。
Spring Boot默认提供静态资源⽬录位置需置于classpath下，⽬录名需符合如下规则：

/static 1
/public 2
/resources 3
/META-INF/resources

修改默认的静态资源⽬录：spring.resources.static-locations=....

模板引擎

Spring Boot强烈建议使⽤模板引擎渲染html⻚⾯，避免使⽤JSP，若⼀定要使⽤JSP将⽆法
实现Spring Boot的多种特性。
⽼师在这⾥讲两种模板引擎的集成：Thymeleaf(spring boot推荐), FreeMarker

Thymeleaf
Spring boot默认的模板配置路径为： src/main/resources/templates 。当然也可以修改
这个路径
集成Thymeleaf步骤：
1.修改pom.xml， 增加如下依赖

org.springframework.boot
spring-boot-starter-thymeleaf

2.编写Controller（和springmvc没区别）

3.在src/main/resources/下⾯建⽴login.html页面

thymeleaf的具体使用教程可以参考文档：https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html#using-texts

4.运⾏spring boot，浏览器输⼊：http://localhost:8080/toLogin

Thymeleaf的默认参数配置（供参考）：

# Enable MVC Thymeleaf view resolution.  
spring.thymeleaf.enabled=true  
# Enable template caching.
spring.thymeleaf.cache=true  
# Check that the templates location exists.
spring.thymeleaf.check-template-location=true  
# Content-Type value.
spring.thymeleaf.content-type=text/html  
# Template encoding.
spring.thymeleaf.encoding=UTF-8  
# Comma-separated list of view names that should be excluded from resolution.
spring.thymeleaf.excluded-view-names=  
# Template mode to be applied to templates. See also
StandardTemplateModeHandlers.spring.thymeleaf.mode=HTML5  
# Prefix that gets prepended to view names when building a URL.
spring.thymeleaf.prefix=classpath:/templates/  
# Suffix that gets appended to view names when building a URL.
spring.thymeleaf.suffix=.html
# Order of the template resolver in the chain.
spring.thymeleaf.template-resolver-order=
# Comma-separated list of view names that can be resolved.
spring.thymeleaf.view-names= 

FreeMarker

1.修改pom.xml，增加依赖

      org.springframework.boot
      spring-boot-starter-freemarker
    

2.写Controller

@RequestMapping("/testFreemarker")
  public String testFreemarker(Map map) {
map.put("name", "张三");
  return "hello"; //默认为src/main/resources/templates/hello.ftl
  }

hello.htl

  hello, ${name}

3运⾏spring boot main，浏览器输⼊如下地址：http://localhost:8080/testFreemarker

集成Swagger2构建RESTful API⽂档

[Swagger2提供以下能⼒]：
1.随项⽬⾃动⽣成强⼤RESTful API⽂档，减少⼯作量
2.API⽂档与代码整合在⼀起，便于同步更新API说明
3.⻚⾯测试功能来调试每个RESTful API
[集成Swagger2步骤]：
1.修改pom.xml， 添加Swagger2依赖

io.springfox
springfox-swagger2
2.2.2


io.springfox
springfox-swagger-ui
2.2.2

2.创建Swagger2配置类
在spring boot启动类所在包或⼦包中创建Swagger配置类SwaggerConfig.java，如下：

SwaggerConfig.java内容如下：

package com.cym.springboot.swagger2;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;


@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                // 指定扫描包下面的注解
                .apis(RequestHandlerSelectors.basePackage("com.cym.springboot.swagger2"))
                .paths(PathSelectors.any())
                .build();
    }
    // 创建api的基本信息
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("集成Swagger2")
                .description("集成Swagger2构建RESTful APIs")
                .termsOfServiceUrl("https://www.baidu.com")
                .contact("zhangsan")
                .version("1.0.0")
                .build();
    }
}

3.创建Controller: SwaggerController.java

@RestController
@RequestMapping(value = "/swagger")
public class SwaggerController {

    @ApiOperation(value = "获取用户信息", notes = "根据id来获取用户详细信息")
    @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "String")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public Map getInfo(@PathVariable String id) {
        Map map = new HashMap();
        map.put("name", "张三");
        map.put("age", "34");
        return map;
    }
}

4.启动Spring boot，访问Swagger UI界⾯：http://localhost:8081/swagger-ui.html
5.测试API:

统⼀异常处理
创建全局异常处理类：通过使⽤ @ControllerAdvice 定义统⼀的异常处理类，
@ExceptionHandler ⽤来定义针对的异常类型
1.增加异常类

package com.cym.springboot.exception;

import javax.servlet.http.HttpServletRequest;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;

@ControllerAdvice
class GlobalExceptionHandler {

    @ExceptionHandler(value = Exception.class)
    public ModelAndView defaultErrorHandler(HttpServletRequest req, Exception e)
            throws Exception {
        ModelAndView mav = new ModelAndView();
        mav.addObject("msg", "发生异常...");
        mav.setViewName("error");
        return mav;
    }
}

2.增加Controller⽅法，抛出异常：

3.src/main/resources/templates增加error.ftl

  ${msg}

集成Mybatis

集成步骤：
1.修改pom.xml,增加依赖

    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    1.3.1



mysql
    mysql-connector-java
    5.1.30
    runtime

2.mysql的连接配置

application.yaml:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/mybatis
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource

application.properties:

spring.datasource.url=jdbc:mysql://localhost:3306/mybatis
spring.datasource.username=root 
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

 3.创建表person

CREATE TABLE `person` (
  `PERSON_ID` int(10) NOT NULL AUTO_INCREMENT,
  `NAME` varchar(10) DEFAULT NULL,
  `GENDER` int(1) DEFAULT NULL,
  `PERSON_ADDR` varchar(50) DEFAULT NULL,
  `BIRTHDAY` date DEFAULT NULL,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`PERSON_ID`)
) ENGINE=InnoDB AUTO_INCREMENT=1000022 DEFAULT CHARSET=utf8;

4.创建Person.java

package com.cym.springboot.model;


import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.Date;

@Setter
@Getter
@ToString
public class Person {
    private Integer personId;

    private String name;

    private Integer gender;

    private String personAddr;

    private Date birthday;

}

5.创建 PersonMapper.java接⼝⽂件(如果是接口文件需要在上面加入一个@Mapper或者在配置类（或者启动类）上面@MapperScan("com.cym.springboot.dao") （扫描的包名）)

package com.cym.springboot.mapper;


import com.cym.springboot.model.Person;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface PersonMapper {

    @Select("select * from person")
   /* @Results(value = {
            @Result(column = "person_id",property = "personId",id = true),
            @Result(column = "name",property = "name"),
            @Result(column = "birthday",property = "birthday"),
            @Result(column = "person_addr",property = "personAddr"),
            @Result(column = "gender",property = "gender")
    })*/
    public List selectPersons();

    @Insert("insert into person(person_id,name,gender,person_addr,birthday) values(" +
            "#{personId},#{name},#{gender},#{personAddr},#{birthday})")
    @SelectKey(before = false,keyProperty = "personId",resultType = Integer.class,statement = {"select LAST_INSERT_ID()"})
    public void insertPerson(Person person);

    @Delete("delete from person where person_id = #{id}")
    public void deletePerson(Integer id);
}

6.测试

package com.cym.springboot;

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootDemo9ApplicationTests {

	/*@Autowired
	DataSource dataSource;*/
	@Autowired
	JdbcTemplate jdbcTemplate;
	@Autowired
	PersonMapper personMapper;
	@Test
	public void contextLoads() {
		List> maps = jdbcTemplate.queryForList("SELECT * FROM person");
		System.out.println(maps);
	}
	@Test
	public void testMybatis() {
		List list = personMapper.selectPersons();
		System.out.println(list);
	}
	@Test
	public void testMybatis1() {
		Person person = new Person();
		person.setName("李白");
		person.setBirthday(new Date());
		person.setGender(1);
		person.setPersonAddr("王者峡谷");
		personMapper.insertPerson(person);
	}
	@Test
	public void testMybatis2() {
		personMapper.deletePerson(1000022);
	}

}

注意：测试完毕之后，记得把这个 测试类注释掉 ，不然后⾯构建整个项⽬的时候会执⾏test
case,导致编译不成功

集成redis

集成Redis集成步骤：
1.修改pom.xml,增加依赖

org.springframework.boot
spring-boot-starter-data-redis

 注意：旧版本spring boot中集成的redis starter为：spring-boot-starter-redis

2.redis连接配置

# REDIS (RedisProperties)
# Redis数据库索引（默认为0）
spring.redis.database=0 
# Redis服务器地址
spring.redis.host=127.0.0.1 5
# Redis服务器连接端口
spring.redis.port=6379 
# Redis服务器连接密码（默认为空）
spring.redis.password= 9
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接 
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0 

注意：spring.redis.database的配置通常使⽤0即可，Redis在配置的时候可以设置数据库数
量，默认为16，可以理解为数据库的schema

3.启动redis(自行启动)

4.测试

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class SpringRedisTest {
	@Autowired
	private RedisTemplate redisTemplate;
	@Test
	public void testRedis() throws Exception {
		ValueOperations ops = redisTemplate.opsForValue();
		ops.set("name", "zhangsan");
		String value = ops.get("name");
		System.out.println(value);
		TestCase.assertEquals("zhangsan", value);
    }
}

集成RabbitMQ

RabbitMQ是以AMQP协议实现的⼀种消息中间件产品，
AMQP是Advanced Message Queuing Protocol的简称，它是⼀个⾯向消息中间件的
开放式标准应⽤层协议。AMQP中定义了以下标准特性：

消息方向

消息队列

消息路由（包括：点到点模式和发布-订阅模式）

可靠性

安全性

关于AMQP 、RabbitMQ的详细内容不再这里过多介绍，本次课主要讲怎么与Spring boot集成

1.安装RabbitMQ[windows]

Erlang/OTP 20.3下载地址：

http://erlang.org/download/otp_win64_20.3.exe

Erlang/OTP其它版本下载地址：http://www.erlang.org/downloads

RabbitMQ Server 3.7.4下载地址：

https://dl.bintray.com/rabbitmq/all/rabbitmq-server/3.7.4/rabbitmq-server-3.7.4.exe 

RabbitMQ其它版本下载地址：https://www.rabbitmq.com/download.html

2.启动RabbitMQ Server

RabbitMQ Server安装之后，会自动注册为windows服务，并以默认配置启动起来

3.RabbitMQ管理页面

1.开启Web管理插件

进入rabbitmq安装目录的sbin目录，在此打开dos命令窗口，执行以下命令

rabbitmq-plugins enable rabbitmq_management

出现如下提示，说明web管理插件安装成功

 然后重新启动RabbitMQ 服务，打开浏览器并访问：http://localhost:15672/，并使用默认用户guest登录，密码也为guest，即可进入管理界面

注意：完成上面的步骤后一定要重启RabbitMQ 服务的服务，第一次可能还是访问不到，可以等一下在刷新，或者再次重启

Spring Boot整合

1.修改pom.xml，增加依赖支持

   

        org.springframework.boot

        spring-boot-starter-amqp

   

2.新增管理用户并设置权限

1.Add a user

username:springboot

password:123456

2.切换到springboot用户登陆，在All users中，点击Name为springboot， 进入权限设置页面

3.在权限设置页面，进入Permissions页面，点击“Set permission"

3.rabbit mq连接配置

## rabbitmq config

spring.rabbitmq.host=localhost

spring.rabbitmq.port=5672

spring.rabbitmq.username=springboot

spring.rabbitmq.password=123456

 4.创建Rabbit配置类

package com.cym.springboot.rabbitmq;

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration
public class RabbitConfig {
    @Bean
    public Queue firstQueue() {
    	// 创建一个队列，名称为：first
        return new Queue("first");
    }
}

5.创建消息产生者类

package com.cym.springboot.rabbitmq;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Sender {
    @Autowired
    private AmqpTemplate rabbitTemplate;
    public void send() {
        rabbitTemplate.convertAndSend("first", "test rabbitmq message !!!");
    }
}

说明：通过注入AmqpTemplate接口的实例来实现消息的发送，AmqpTemplate接口定义了一套针对AMQP协议的基础操作

6.创建消息消费者

package com.cym.springboot.rabbitmq;

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
@RabbitListener(queues = "first")
public class Receiver {
    @RabbitHandler
    public void process(String msg) {
        System.out.println("receive msg : " + msg);
    }
}

说明：

@RabbitListener注解：定义该类需要监听的队列

@RabbitHandler注解：指定对消息的处理

6.创建测试类

package com.cym.springboot;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class RabbitmqTest {

	@Test
	public void contextLoads() {
		@Autowired
		private Sender sender;
		@Test
		public void testRabbitmq() throws Exception {
			sender.send();
		}

	}

}

7.启动主程序：SpringBootMain

控制台如果出现以下信息，则说明rabbitmq连接成功

Created new connection: rabbitConnectionFactory#29102d45:0/SimpleConnection@1dcfb5ba [delegate=amqp://[email protected]:5672/, localPort= 55088]

8.运行Junit测试类

控制台输出：

receive msg : test rabbitmq message !!!

集成Rabbit MQ完毕!

Spring boot 日志

Java 有很多日志系统，例如，Java Util Logging, Log4J, Log4J2, Logback 等。Spring Boot 也提供了不同的选项，比如日志框架可以用 logback 或 log4j ，log4j2等。

默认的日志框架 logback

springboot自带log日志功能 使用的是slf4j(Simple Logging Facade For Java)，它是一个针对于各类Java日志框架的统一Facade抽象

日志实现默认使用的logback

Logback是log4j框架的作者开发的新一代日志框架，它效率更高、能够适应诸多的运行环境，同时天然支持SLF4J。这是默认支持logback的原因

例如，在spring-boot-starter 依赖中，添加了 spring-boot-starter-logging依赖

    org.springframework.boot

    spring-boot-starter-logging

那么， Spring Boot 应用将自动使用 logback 作为应用日志框架， Spring Boot 启动的时候，由 org.springframework.boot.logging.Logging.LoggingApplicationListener 根据情况初始化并使用。

值得注意的是，默认情况下，Spring Boot 使用 logback 作为应用日志框架。因为 spring-boot-starter 其中包含了 spring-boot-starter-logging，该依赖就是 使用Spring Boot 默认的日志框架 logback

package com.cym.springboot.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;
@Controller
public class TestController {

    private final Logger logger = LoggerFactory.getLogger(TestController.class);
    @RequestMapping("/testFreemarker")
    public String testFreemarker(Map map) {
        logger.info("test{}"+"日志测试");
        map.put("name", "张三");
        return "hello"; //默认为src/main/resources/templates/hello.ftl
    }
}

访问：http://localhost:8080/testFreemarker

日志级别

默认情况下，Spring Boot 配置的是INFO 日志级别，也就是会输出INFO级别以上的日志（ ERROR, WARN, INFO ）。如果需要 Debug 级别的日志。在 src/main/resources/application.properties 中配置。

debug=true

此外，配置 logging.level.* 来具体输出哪些包的日志级别。

例如

logging.level.root=INFO

logging.level.org.springframework.web=DEBUG

logging.level.com.example.boot.controller=DEBUG

日志文件

默认情况下， Spring Boot 日志只会输出到控制台，并不会写入到日志文件，因此，对于正式环境的应用，我们需要通过在 application.properites 文件中配置 logging.file 文件名称和 logging.path 文件路径，将日志输出到日志文件中。

logging.path = /var/tmp

logging.file = xxx.log

logging.level.root = info

如果只配置 logging.path，在 /var/tmp文件夹生成一个日志文件为 spring.log。如果只配置 logging.file，会在项目的当前路径下生成一个 xxx.log 日志文件。

值得注意的是，日志文件会在 10MB 大小的时候被截断，产生新的日志文件。

常用的日志框架 log4j

如果，我们希望使用 log4j 或者 log4j2，我们可以采用类似的方式将它们对应的依赖模块加到 Maven 依赖中。

集成log4j2

在spring-boot-dependencies POMs中搜索spring-boot-starter-log4j2

发现Spring boot父Pom中自己提供了这个依赖，于是我们加入如下jar依赖：

    org.springframework.boot

    spring-boot-starter

   

       

            org.springframework.boot

            spring-boot-starter-logging

       

   

    org.springframework.boot

    spring-boot-starter-log4j2

⽇志使⽤跟上⾯logback⼀样。

集成log4j

在spring-boot-dependencies POMs中搜索 spring-boot-starter-log4j
发现Spring boot的⽗Poms中⾃⼰ 并没有提供了这个依赖， 我们在http://mvnrepository.com中央仓库中查找

1.加⼊pom依赖

            org.springframework.boot
            spring-boot-starter
            
                
                    org.springframework.boot
                    spring-boot-starter-logging
                
            
        

    org.springframework.boot
    spring-boot-starter-log4j
    1.3.8.RELEASE

2.classpath下增加log4j.properties

log4j.rootCategory=INFO, stdout, file, errorfile
log4j.category.com.example.boot=INFO, myFile
log4j.logger.error=errorfile

# 控制台输出
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

# root日志输出
log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.file=logs/all.log
log4j.appender.file.DatePattern='.'yyyy-MM-dd
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

# error日志输出
log4j.appender.errorfile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.errorfile.file=logs/error.log
log4j.appender.errorfile.DatePattern='.'yyyy-MM-dd
log4j.appender.errorfile.Threshold = ERROR
log4j.appender.errorfile.layout=org.apache.log4j.PatternLayout
log4j.appender.errorfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L - %m%n

# com.example.boot下的日志输出
log4j.appender.myFile=org.apache.log4j.DailyRollingFileAppender
log4j.appender.myFile.file=logs/my.log
log4j.appender.myFile.DatePattern='.'yyyy-MM-dd
log4j.appender.myFile.layout=org.apache.log4j.PatternLayout
log4j.appender.myFile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss,SSS} %5p %c{1}:%L ---- %m%n

3.代码中使用log4j

import org.apache.log4j.Logger;

private final Logger logger = Logger.getLogger(xxx.class);

自定义视图映射

在项目开发过程中，经常会涉及页面跳转问题，而且这个页面跳转没有任何业务逻辑过程，只是单纯的路由过程 ( 例如：点击一个按钮跳转到一个页面 )

正常的写法是这样的：

@RequestMapping("/testmvc")

 public String view(){

    return "abc";

 }

现在只需要这样统一写，此类必须在启动类所在包或者子包中：

@Configuration

public class MVCConfig implements WebMvcConfigurer {

    @Override
    public void addViewControllers(ViewControllerRegistry registry) {
        registry.addViewController("/header").setViewName("header");
        registry.addViewController("/index").setViewName("index");
        registry.addViewController("/menu").setViewName("menu");
        registry.addViewController("/toAdd").setViewName("add");
        registry.addViewController("/toLogin").setViewName("login");
    }

   
}

拦截器的使用：其实也很简单

1. 创建拦截器

package com.cym.springboot.interceptor;

import com.cym.springboot.model.Person;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Person user = (Person) request.getSession().getAttribute("user");
        if (user != null){
            return true;
        }
        response.sendRedirect(request.getContextPath()+"/toLogin");
        return false;
    }
}

拦截器注册

@Configuration

public class MVCConfig implements WebMvcConfigurer {

    /**
     * 注册拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List excludePatterns = new ArrayList();
        excludePatterns.add("/css/**");
        excludePatterns.add("/images/**");
        excludePatterns.add("/toLogin");
        excludePatterns.add("/login");

        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns(excludePatterns);
    }
}

当我们做文件上传的时候我们也会发现multipartResolver是自动被配置好的

页面

Controller

@ResponseBody
@RequestMapping("/upload")
public String upload(@RequestParam("pic")MultipartFile file, HttpServletRequest request){
    String contentType = file.getContentType();
    String fileName = file.getOriginalFilename();
    /*System.out.println("fileName-->" + fileName);
    System.out.println("getContentType-->" + contentType);*/
    //String filePath = request.getSession().getServletContext().getRealPath("imgupload/");
    String filePath = "D:/imgup";
    try {
        this.uploadFile(file.getBytes(), filePath, fileName);
    } catch (Exception e) {
        // TODO: handle exception
    }

    return "success";
}


public static void uploadFile(byte[] file, String filePath, String fileName) throws Exception {
    File targetFile = new File(filePath);
    if(!targetFile.exists()){
        targetFile.mkdirs();
    }
    FileOutputStream out = new FileOutputStream(filePath+fileName);
    out.write(file);
    out.flush();
    out.close();
}

文件上传大小可以通过配置来修改 打开application.properties, 默认限制是10MB，我们可以任意修改