王竹根
王竹根

SpringBoot

源码仓库地址：https://gitee.com/DerekAndroid/agan-boot.git

配套免费视频教程 https://study.163.com/course/introduction/1004576013.htm?share=1&shareId=1016481220

github源码地址：https://github.com/agan-java/agan-boot

SpringBoot入门篇

1.spring-boot是什么，出现的背景

SpringBoot_第1张图片

2.spring-boot是jar包+tomcat

SpringBoot_第2张图片

springBoot入门例子代码：

https://gitee.com/DerekAndroid/agan-boot/tree/master/01/agan-boot-helloworld

效果：

SpringBoot_第3张图片

@SpringBootApplication启动原理

三：@SpringBootApplication就只干了一件事
以上所有注解就只干一件事：把bean注册到spring ioc容器。
通过3种方式来实现：
1. @SpringBootConfiguration 通过@Configuration 与@Bean结合，注册到Spring ioc 容器。
2. @ComponentScan  通过范围扫描的方式，扫描特定注解类，将其注册到Spring ioc 容器。
3. @EnableAutoConfiguration 通过spring.factories的配置，来实现bean的注册到Spring ioc 容器。

# 解密@SpringBootApplication启动原理
### 一：本课程目标：
学习spring boot的核心注解@SpringBootApplication，掌握@SpringBootApplication的原理。

### 二：剖析@SpringBootApplication源码
首先我们来分析springboot的启动注解@SpringBootApplication
``` 
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication 
```
@Target(ElementType.TYPE)  注解的目标位置:接口、类、枚举
@Retention(RetentionPolicy.RUNTIME)  注解会在class字节码文件中存在，在运行时可以通过反射获取到
@Documented 用于生成javadoc,默认情况下,javadoc是不包括注解的. 但如果声明注解时指定了 @Documented,
则它会被 javadoc 之类的工具处理,所以注解类型信息也会被包括在生成的文档中。
@Inherited 作用：在类继承关系中，如果子类要继承父类的注解，那么要该注解必须被@Inherited修饰的注解
除了以上常规的几个注解，剩下几个就是springboot的核心注解了。
@SpringBootApplication就是一个复合注解，包括@ComponentScan，和@SpringBootConfiguration，@EnableAutoConfiguration。

### 三：@SpringBootApplication就只干了一件事
以上所有注解就只干一件事：把bean注册到spring ioc容器。
通过3种方式来实现：
1. @SpringBootConfiguration 通过@Configuration 与@Bean结合，注册到Spring ioc 容器。
2. @ComponentScan  通过范围扫描的方式，扫描特定注解类，将其注册到Spring ioc 容器。
3. @EnableAutoConfiguration 通过spring.factories的配置，来实现bean的注册到Spring ioc 容器。

springboot端口配置和自定义属性配置

## 一、本课程目标：
 在前面的《SpringBoot的入门例子》的课程基础上，我们继续来讲解springboot的常用配置，
   即讲解resources包下的application.properties如何使用。
   
## 二、最常用的配置1：改端口
``` 
server.port=9090
```

## 三、最常用的配置2：改随机端口
思考问题：固定端口为什么不能用？为什么要改随机端口？
1.如果在用一台服务器上，多个服务如果用同一个端口会造成端口冲突。
2.在现实的微服务(springcloud、dubbo)开发中，开发人员是不用记住ip和端口的.
故，我们一般在真实的开发环境下，是设置一个随机端口，就不用去管理端口了，也不会造成端口冲突。
``` 
server.port=${random.int[1024,9999]}
```

## 四、自定义属性配置
讲自定义属性配置，就必须讲解@value注解。

@value的作用是：为了简化读取properties文件中的配置值，spring支持@value注解的方式来获取，这种方式大大简化了项目配置，提高业务中的灵活性。

在application.properties的文件下，加入如下配置
``` 
agan.msg=hi,hello world!!
```

``` 

@RestController
public class HelloController {
    
    @Value("${agan.msg}")
    private  String msg;

    @GetMapping("msg")
    public String getMsg() {
        return msg;
    }
}

yml格式的配置文件

## 一、本课程目标：
学习什么是yml文件？和学习yml语法。
SpringBoot的配置文件有两种，一种是properties结尾的，一种是以yaml或yml文件结尾的。
1.	application.properties
1.	application.yml
默认情况下是properties结尾的配置文件
配置文件放在src/main/resources目录或者类路径/config/下


## 二、先弄清楚，什么是yml文件？
yml是YAML（YAML Ain't Markup Language）语言的文件，以数据为中心，比json、xml等更适合做配置文件

## 三、对比区别
``` 
server.port=9090

agan.msg=hi,hello world!!
```
转换为yml配置文件
``` 
server：
   port： 9090

agan：
   msg： hi,hello world!!
```
以空格的缩进程度来控制层级关系。（空格个数不重要）

日志配置

## 一：本课程目标：
学习springboot日志的框架，学完后会设置日志级别、设置日志的存储路径、设置日志的格式等等。

## 二：剖析springboot的日志框架
  slf4j
 logback、log4j
 从springboot的底层框架spring-boot-starter-logging 可以看出，它依赖了3个框架分别为；slf4j、logback、log4j
 
### 分析1：slf4j、logback、log4j的区别？
1.logback、log4j：是日志实现框架，就是实现怎么记录日志的。
2.slf4j：提供了java中所有的日志框架的简单抽象（日志的门面设计模式），说白了就是一个日志API（没有实现类），它不能单独使用
故：必须结合logback或log4j日志框架来实现。
 
### 分析2：springboot的日志搭配
springboot2.0默认采用了slf4f+logback的日志搭配。
在开发过程中，我们都是采用了slf4j的api去记录日志，底层的实现就是根据配置logback或log4j日志框架。

##代码添加
private static  final Logger logger= LoggerFactory.getLogger(HelloController.class);

##为什么控制台的日志只输出了 info  warn error?
因为springboot默认是info级别的
```
logging.level.com.agan.boot=trace

```

## 三：配置日志的生成存储路径和日志名称
在实际的开发中，你不可能一直看着控制台，而且日志会非常大，瞬间就丢失。
故，我们要把日志存储在指定的目录下；
``` 

#一下配置的效果为：项目根目录下/output/logs/spring.log,默认的日志名为spring.log
#logging.path=output/logs

# 如果不想要把日志存放在longging.path默认的根目录下，那就采用自定义的目录和文件名
logging.file=/Volumes/data/logs/springboot.log
```
## 三：配置日志的内容格式

``` 
# %d-时间格式、%thread-线程、%-5level-从左5字符宽度、%logger{50}-日志50个字符、%msg-信息、%n-换行
# 设置在控制台输出的日志格式
logging.pattern.console=%d{yyyy-MM-dd} [%thread] %-5level %logger{50} -%msg%n
# 设置输出到文件的日志格式
logging.pattern.file=%d{yyyy/MM/dd} === [%thread] == %-5level == %logger{50} == %msg%n

代码：

@RestController
public class HelloController {
    private static  final Logger logger= LoggerFactory.getLogger(HelloController.class);

    @Value("${agan.msg}")
    private  String msg;

    @GetMapping("msg")
    public String getMsg() {
        return msg;
    }

    @GetMapping("/home")
    public String home(){
        return "hello agan!";
    }

    @GetMapping("/log")
    public void log(){
        logger.trace("------------trace-----------");
        logger.debug("------------debug-----------");
        logger.info("------------info-----------");
        logger.warn("------------warn-----------");
        logger.error("------------error-----------");

    }
}

 日志配置文件xml方式

1.集成到springboot的yml格式配置文件的示例：

logging:
  config: classpath:logback-spring.xml
  level:
#    根目录输出warn级别日志
    root: warn
#    当前包名输出trace级别日志
    com.example.demo: trace
#  pattern:
#    console: '%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} - %msg%n'

2. logback-spring.xml配置文件




    

    

    


    　
    　　　　　　　　testFile.log
    　　　　　　　　true
    　　　　　　　　
    　　　　　　　　　　%-4relative [%thread] %-5level %logger{35} - %msg%n
    　　　　　　　　
    　

    
    

    
    

    
    

        
        
            %d{yyyy-MM-dd HH:mm:ss} [%X{x-log-requestid}] [%thread] %-5level %logger{50} - %msg%n
            utf8

效果：

SpringBoot_第4张图片 

参考：https://www.jianshu.com/p/bea462da206b

https://www.cnblogs.com/magic-s/p/9155288.html

https://www.cnblogs.com/gavincoder/p/10091757.html

https://www.cnblogs.com/javalanger/p/10964603.html

lombok中核心注解@Data+@Slf4j

#在springboot中使用lombok

##一、本课程目标：
1.学会安装lombok插件，并学会用lombok。
2.掌握lombok的核心@Data注解
3.掌握lombok的核心@Slf4j注解


##二、为什么要使用lombok,它解决了什么问题？
Lombok 是一个 IDEA 插件,也是一个依赖jar 包。
它解决了开发人员少写代码，提升开发效率。
它使开发人员不要去写javabean的getter/setter方法，写构造器、equals等方法；最方便的是你对javabean的属性增删改，
你不用再重新生成getter/setter方法。省去一大麻烦事。

##三、idea安装lombok插件
###步骤1：idea搜索lombok插件
打开IDEA的Settings面板，并选择Plugins选项，然后点击 “Browse repositories..”
![image](https://github.com/agan-java/images/blob/master/lombok/14.png?raw=true)

###步骤2：安装并重启idea
点击安装，然后安装提示重启IDEA，安装成功;
![image](https://github.com/agan-java/images/blob/master/lombok/15.png?raw=true)
记得重启IDEA，不然不生效。


### 四、体验lombok核心注解@data
#### 步骤1： 什么是@data注解
@Data 注解在实体类上，自动生成javabean的getter/setter方法，写构造器、equals等方法；

#### 步骤2：pom文件添加依赖包
``` 

    org.projectlombok
    lombok
    1.18.8

```
### 五、体验lombok第二核心注解@Slf4j
注解@Slf4j的作用就是代替一下代码
``` 
private static final Logger logger = LoggerFactory.getLogger(UserController.class);
```
让你不用每次都写重复的代码

代码

@RestController
@Slf4j
public class UserController {

    //private static final Logger logger = LoggerFactory.getLogger(UserController.class);

    @RequestMapping("/user")
    public  UserVO  user() {
        UserVO userVO=new UserVO();
        userVO.setId(100);
        userVO.setUsername("agan");
        return userVO;
    }

    @RequestMapping("/log")
    public  void  log() {
        log.trace("-----------trace-------------");
        log.debug("-----------debug-------------");
        log.info("-----------info-------------");
        log.warn("-----------warn-------------");
        log.error("-----------error-------------");
    }
}

三大框架的日志冲突解决问题ssh-ssm

SpringBoot_第5张图片

使用代替包兼容slf4j

 

SpringBoot_第6张图片

异步框架@Async注解+线程池

Spring Boot 异步框架
### 一、课程目标
熟悉spring的异步框架，学会使用异步@Async注解


### 二、为什么要用异步框架，它解决什么问题？

在SpringBoot的日常开发中，一般都是同步调用的。但经常有特殊业务需要做异步来处理，例如：注册新用户，送100个积分，或下单成功，发送push消息等等。
就拿注册新用户为什么要异步处理？
- 第一个原因：容错性、健壮性，如果送积分出现异常，不能因为送积分而导致用户注册失败；
因为用户注册是主要功能，送积分是次要功能，即使送积分异常也要提示用户注册成功，然后后面在针对积分异常做补偿处理。
- 第二个原因：提升性能，例如注册用户花了20毫秒，送积分花费50毫秒，如果用同步的话，总耗时70毫秒，用异步的话，无需等待积分，故耗时20毫秒。
故，异步能解决2个问题，性能和容错性。

### 三、SpringBoot异步调用
在SpringBoot中使用异步调用是很简单的，只需要使用@Async注解即可实现方法的异步调用。

### 四、@Async异步调用例子
#### 步骤1：开启异步任务
采用@EnableAsync来开启异步任务支持，另外需要加入@Configuration来把当前类加入springIOC容器中。
``` 
@Configuration
@EnableAsync
public class SyncConfiguration {

}
```
#### 步骤2：在方法上标记异步调用
增加一个service类，用来做积分处理。
@Async添加在方法上，代表该方法为异步处理。
``` 
public class ScoreService {

    private static final Logger logger = LoggerFactory.getLogger(ScoreService.class);

    @Async
    public void addScore(){
        //TODO 模拟睡5秒，用于赠送积分处理
        try {
            Thread.sleep(1000*5);
            logger.info("--------------处理积分--------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}
```

### 五、为什么要给@Async自定义线程池？
@Async注解，在默认情况下用的是SimpleAsyncTaskExecutor线程池，该线程池不是真正意义上的线程池，因为线程不重用，每次调用都会新建一条线程。
可以通过控制台日志输出查看，每次打印的线程名都是[task-1]、[task-2]、[task-3]、[task-4].....递增的。
@Async注解异步框架提供多种线程
SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，每次调用都会创建一个新的线程。
SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方
ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类
ThreadPoolTaskScheduler：可以使用cron表达式
ThreadPoolTaskExecutor ：最常使用，推荐。 其实质是对java.util.concurrent.ThreadPoolExecutor的包装

### 六、为@Async实现一个自定义线程池
#### 步骤1：配置线程池
```
@Configuration
@EnableAsync
public class SyncConfiguration {
    @Bean(name = "scorePoolTaskExecutor")
    public ThreadPoolTaskExecutor getScorePoolTaskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        //核心线程数
        taskExecutor.setCorePoolSize(10);
        //线程池维护线程的最大数量,只有在缓冲队列满了之后才会申请超过核心线程数的线程
        taskExecutor.setMaxPoolSize(100);
        //缓存队列
        taskExecutor.setQueueCapacity(50);
        //许的空闲时间,当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        taskExecutor.setKeepAliveSeconds(200);
        //异步方法内部线程名称
        taskExecutor.setThreadNamePrefix("score-");
        /**
         * 当线程池的任务缓存队列已满并且线程池中的线程数目达到maximumPoolSize，如果还有任务到来就会采取任务拒绝策略
         * 通常有以下四种策略：
         * ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
         * ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
         * ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
         * ThreadPoolExecutor.CallerRunsPolicy：重试添加当前的任务，自动重复调用 execute() 方法，直到成功
         */
        taskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        taskExecutor.initialize();
        return taskExecutor;
    }
}

```


#### 步骤2： 为@Async指定线程池名字
``` 
    @Async("scorePoolTaskExecutor")
    public void addScore2(){
        //TODO 模拟睡5秒，用于赠送积分处理
        try {
            Thread.sleep(1000*5);
            log.info("--------------处理积分--------------------");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
```

效果：

swagger

# SpringBoot集成swagger实战

### 一、本课程目标：
1. 弄清楚，为什么要用swagger，它解决了什么问题？
2. 编码实现2个springboot接口，让swagger自动生成接口文档


### 二、为什么要用swagger,它解决了什么问题？
随着sprnigboot、springcloud等微服务的流行，在微服务的设计下，小公司微服务小的几十，大公司大的几百上万的微服务。
这么多的微服务必定产生了大量的接口调用。而接口的调用就必定要写接口文档。
在微服务的盛行下，成千上万的接口文档编写，不可能靠人力来编写，故swagger就产生了，它采用自动化实现并解决了人力编写接口文档的问题；
它通过在接口及实体上添加几个注解的方式就能在项目启动后自动化生成接口文档，

Swagger 提供了一个全新的维护 API 文档的方式，有4大优点：
1.自动生成文档：只需要少量的注解，Swagger 就可以根据代码自动生成 API 文档，很好的保证了文档的时效性。
2.跨语言性，支持 40 多种语言。
3.Swagger UI 呈现出来的是一份可交互式的 API 文档，我们可以直接在文档页面尝试 API 的调用，省去了准备复杂的调用参数的过程。
4.还可以将文档规范导入相关的工具（例如 SoapUI）, 这些工具将会为我们自动地创建自动化测试。


### 三、案例实战：把springboot的接口，自动生成接口文档

#### 步骤1： pom文件加入依赖包
``` 



    io.springfox
    springfox-swagger2
    2.9.2



    io.springfox
    springfox-swagger-ui
    2.9.2

```
#### 步骤2：修改配置文件
1. application.properties 加入配置
``` 
#表示是否开启 Swagger，一般线上环境是关闭的
spring.swagger2.enabled=true
```
2.增加一个swagger配置类
``` 
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Value(value = "${spring.swagger2.enabled}")
    private Boolean swaggerEnabled;

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .enable(swaggerEnabled)
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.agan.boot"))
                .paths(PathSelectors.any())
                .build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("接口文档")
                .description("阿甘讲解 Spring Boot")
                .termsOfServiceUrl("https://study.163.com/provider/1016671292/index.htm")
                .version("1.0")
                .build();
    }
}
```
以上注意点：
1.createRestApi() 这个方法一定要写上你的包名名，代表需要生成接口文档的目录包

体验地址：http://127.0.0.1:9090/swagger-ui.html

swagger常用注解

 Swagger 常用注解		
注解	用途	注解位置
@Api	描述类的作用	注解于类上
@ApiOperation	描述类的方法的作用	注解于方法上
@ApiParam	描述类方法参数的作用	注解于方法的参数上
@ApiModel	描述对象的作用	注解于请求对象或者返回结果对象上
@ApiModelProperty	描述对象里字段的作用	注解于请求对象或者返回结果对象里的字段上

对象注解示例：

@ApiModel(value = "用户信息")
@Data
public class UserVO {
    @ApiModelProperty(value = "用户ID")
    private Integer id;

    @ApiModelProperty(value = "用户名")
    private String username;

    @ApiModelProperty(value = "密码")
    private String password;

    @ApiModelProperty(value = "性别 0=女 1=男 ")
    private Byte sex;

    @ApiModelProperty(value = "删除标志，默认0不删除，1删除")
    private Byte deleted;

    @ApiModelProperty(value = "更新时间")
    private Date updateTime;

    @ApiModelProperty(value = "创建时间")
    private Date createTime;

}

本地体验地址：http://127.0.0.1:9090/swagger-ui.html

 

MyBatis Generator 代码生成器

# MyBatis 代码生成器

## 一、什么是MyBatis 代码生成器？
MyBatis Generator（简称为：MyBatis 代码生成器） 是MyBatis 官方出品的一款，用来自动生成MyBatis的 mapper、xml、entity 的框架，
让程序员在开发的过程中省去很多重复的工作。
操作非常简单，只要在配置文件中，配置好要生成的表名和包名，然后运行命令，就能自动生成mapper、xml、entity 等一堆文件。

官网地址：http://www.mybatis.org/generator/

## 二、MyBatis Generator搭建步骤
### 步骤1:新建数据库
``` 

CREATE DATABASE `boot_user` /*!40100 DEFAULT CHARACTER SET utf8 */;
use boot_user;

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL DEFAULT '' COMMENT '用户名',
  `password` varchar(50) NOT NULL DEFAULT '' COMMENT '密码',
  `sex` tinyint(4) NOT NULL DEFAULT '0' COMMENT '性别 0=女 1=男 ',
  `deleted` tinyint(4) unsigned NOT NULL DEFAULT '0' COMMENT '删除标志，默认0不删除，1删除',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='用户表';

SET FOREIGN_KEY_CHECKS = 1;

```
### 步骤2:pom.xml依赖包
1. pom.xml的插件
加入 mybatis-generator-maven-plugin
``` 
    
        
            
                ${basedir}/src/main/java
                
                    **/*.xml
                
            
            
                ${basedir}/src/main/resources
            
        
        
            
                maven-compiler-plugin
                
                    ${jdk.version}
                    ${jdk.version}
                
            
            
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.3.6
                
                    ${basedir}/src/main/resources/generatorConfig.xml
                    true
                    true
                
                
                    
                        mysql
                        mysql-connector-java
                        ${mysql.version}
                    
                    
                        tk.mybatis
                        mapper
                        ${mapper.version}
                    
                
            
        
    
```
2. pom.xml加入依赖包

``` 
    
        
        
            org.mybatis.generator
            mybatis-generator-core
            1.3.2
            compile
            true
        
        
        
            tk.mybatis
            mapper
            ${mapper.version}
        
    
```
### 步骤3:2个核心的配置文件
resources配置文件 config.properties
重点要注意：生成的包名
``` 
# 生成的包名
package.name=com.agan.boot

# 数据库配置信息
jdbc.driverClass = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://192.168.0.138:3308/boot_user
jdbc.user = root
jdbc.password =agan

```

最核心的配置文件generatorConfig.xml

``` 






    
    
    
        
        
        
        
        
            
            
        
        
        
        

        
        
        
        
        
        


        
        
        

            

    

```
以上配置 ，一定要修改以下内容
``` 




    

```
### 步骤4:运行generator插件
双击 mybatis-generator:generate# MyBatis 代码生成器

1 sql执行报错  Incorrect table definition; there can be only oneTIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATEclause

解决：修改时间戳，表中存在两个DEFAULT CURRENT_TIMESTAMP属性

  `update_time` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `create_time` TIMESTAMP NOT NULL COMMENT '创建时间',

解决方法2：MySql 5.5和MySql 5.6之后版本的区别：5.5 只能有一个Timestamp,将其中一列类型改为datetime类型就可以解决 

2 Generator插件找不到，如何运行

解决：为当前项目手动添加配置maven任务

SpringBoot_第7张图片

command命令：

mybatis-generator:generate -e

3 自动生成的效果：

druid实现多数据源

agan-boot-mybatis-multi-datasource



# 什么是druid，它解决了什么问题？

Druid是阿里巴巴开源平台上的一个项目，整个项目由数据库连接池、插件框架和SQL解析器组成。
druid主要是为了解决JDBC的一些限制，可以让程序员实现一些特殊的需求，比如向密钥服务请求凭证、统计SQL信息、
SQL性能收集、SQL注入检查、SQL翻译等，程序员可以通过定制来实现自己需要的功能。
官方地址：https://github.com/alibaba/druid
为监控而生的数据库连接池,重点是有个后台监控系统：http://localhost:9090/druid

# 采用druid实现多数据源
## 本案例的多数据源业务场景介绍
在编码之前，我们先来讲解我们这个例子的业务场景。
就用一个微信发红包大家都熟悉来讲解，你用余额给你的好友发了10元红包，
假如：余额和红包分别是2个独立数据库。
这个时候你的余额数据库对应的余额就应该减10元，你的好友的红包数据库就应该加10元。
## 步骤1：建立2个数据库
``` 

CREATE DATABASE `xa_account` /*!40100 DEFAULT CHARACTER SET utf8 */;
use xa_account;


CREATE TABLE `capital_account` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `user_id` int(10) NOT NULL COMMENT '用户ID',
	`balance_amount` decimal(10,0) DEFAULT '0' COMMENT '账户余额',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='账户信息表';
INSERT INTO `capital_account` (`id`,`user_id`,`balance_amount`) VALUES (1,1,2000);






CREATE DATABASE `xa_red_account` /*!40100 DEFAULT CHARACTER SET utf8 */;
use xa_red_account;

CREATE TABLE `red_packet_account` (
  `id` int(10) NOT NULL AUTO_INCREMENT,
  `user_id` int(10) NOT NULL COMMENT '用户ID',
	`balance_amount` decimal(10,0) DEFAULT '0' COMMENT '账户余额',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='红包账户信息表';
INSERT INTO `red_packet_account` (`id`,`user_id`,`balance_amount`) VALUES (1,2,1000);
```

## 步骤2：pom文件加入依赖包

``` 


    tk.mybatis
    mapper-spring-boot-starter
    2.0.3



    com.alibaba
    druid-spring-boot-starter
    1.1.18



    mysql
    mysql-connector-java

```
## 步骤3：修改配置文件
application.properties 必须配置2个数据源 
``` 

# 数据源配置
# 数据源 account
spring.datasource.druid.account.url=jdbc:mysql://192.168.0.138:3308/xa_account?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
spring.datasource.druid.account.username=root
spring.datasource.druid.account.password=agan
spring.datasource.druid.account.driver-class-name=com.mysql.jdbc.Driver
#初始化连接大小:连接池建立时创建的初始化连接数
spring.datasource.druid.account.initial-size=5
#最小空闲连接数:连接池中最小的活跃连接数
spring.datasource.druid.account.min-idle=15
#最大连接数:连接池中最大的活跃连接数
spring.datasource.druid.account.max-active=60
spring.datasource.druid.account.validation-query=SELECT 1
#获取连接时检测：是否在获得连接后检测其可用性
spring.datasource.druid.account.test-on-borrow=true
#空闲时检测：是否在连接空闲一段时间后检测其可用性
spring.datasource.druid.account.test-while-idle=true
#连接保持空闲而不被驱逐的最长时间
spring.datasource.druid.account.time-between-eviction-runs-millis=60000


#数据源 redpacket
spring.datasource.druid.redpacket.url=jdbc:mysql://192.168.0.138:3308/xa_red_account?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
spring.datasource.druid.redpacket.username=root
spring.datasource.druid.redpacket.password=agan
spring.datasource.druid.redpacket.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.druid.redpacket.initial-size=5
spring.datasource.druid.redpacket.min-idle=15
spring.datasource.druid.redpacket.max-active=60
spring.datasource.druid.redpacket.validation-query=SELECT 1
spring.datasource.druid.redpacket.test-on-borrow=true
spring.datasource.druid.redpacket.test-while-idle=true
spring.datasource.druid.redpacket.time-between-eviction-runs-millis=60000


# 合并多个datasource监控
spring.datasource.druid.use-global-data-source-stat=true

#配置druid显示监控统计信息
#开启Druid的监控平台 http://localhost:9090/druid
#1. StatViewServlet配置，说明请参考Druid Wiki，配置_StatViewServlet配置
spring.datasource.druid.stat-view-servlet.enabled=true
spring.datasource.druid.stat-view-servlet.url-pattern=/druid/*
spring.datasource.druid.stat-view-servlet.reset-enable=false
spring.datasource.druid.stat-view-servlet.login-username=admin
spring.datasource.druid.stat-view-servlet.login-password=agan
#spring.datasource.druid.stat-view-servlet.allow=
#spring.datasource.druid.stat-view-servlet.deny=

#2. WebStatFilter配置，说明请参考Druid Wiki，配置_配置WebStatFilter
spring.datasource.druid.web-stat-filter.enabled=true
spring.datasource.druid.web-stat-filter.url-pattern=/*
spring.datasource.druid.web-stat-filter.exclusions=*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*
#spring.datasource.druid.web-stat-filter.session-stat-enable=
#spring.datasource.druid.web-stat-filter.session-stat-max-count=
#spring.datasource.druid.web-stat-filter.principal-session-name=
#spring.datasource.druid.web-stat-filter.principal-cookie-name=
#spring.datasource.druid.web-stat-filter.profile-enable=

#3. Spring监控配置，说明请参考Druid Github Wiki，配置_Druid和Spring关联监控配置
#spring.datasource.druid.aop-patterns= # Spring监控AOP切入点，如x.y.z.service.*,配置多个英文逗号分隔


#Spring Boot2.1以上 默认禁用那种bean覆盖(作用 用于兼容低版本)
spring.main.allow-bean-definition-overriding=true
```
## 步骤4：将配置信息，注入druid
1. 配置2个数据源DataSource
``` 

@Configuration
@EnableConfigurationProperties
@EnableTransactionManagement(proxyTargetClass = true)
public class MybatisConfiguration {
    /**
     * account数据库配置前缀.
     */
    final static String ACCOUNT_PREFIX = "spring.datasource.druid.account";
    /**
     * redpacket数据库配置前缀.
     */
    final static String REDPACKET_PREFIX = "spring.datasource.druid.redpacket";

    /**
     * 配置Account数据库的数据源
     *
     * @return the data source
     */
    @Bean(name = "AccountDataSource")
    @ConfigurationProperties(prefix = ACCOUNT_PREFIX)  // application.properties中对应属性的前缀
    public DataSource accountDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置RedPacket数据库的数据源
     *
     * @return the data source
     */
    @Bean(name = "RedPacketDataSource")
    @ConfigurationProperties(prefix = REDPACKET_PREFIX)  // application.properties中对应属性的前缀
    public DataSource redPacketDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
}
```

2.有了数据源，就要配置数据源的sessionFactory
配置account数据源的sessionFactory
``` 
@Configuration
@MapperScan(basePackages = {"com.agan.boot.mapper.account.mapper"}, sqlSessionFactoryRef = "accountSqlSessionFactory")
public class AccountDataSourceConfiguration {
    /**
     * mybatis的xml文件.
     */
    public static final String MAPPER_XML_LOCATION = "classpath*:com/agan/boot/mapper/account/mapper/*.xml";

    @Autowired
    @Qualifier("AccountDataSource")
    DataSource accountDataSource;

    /**
     * 配置Sql Session模板
     */
    @Bean
    public SqlSessionTemplate springSqlSessionTemplate() throws Exception {
        return new SqlSessionTemplate(accountSqlSessionFactory());
    }

    /**
     * 配置SQL Session工厂
     */
    @Bean
    public SqlSessionFactory accountSqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(accountDataSource);
        //指定XML文件路径
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MAPPER_XML_LOCATION));
        return factoryBean.getObject();
    }

    /**
     *  配置事务
     */
    @Bean(name="transactionManager")
    public DataSourceTransactionManager transactionManager(){
        return new DataSourceTransactionManager(accountDataSource);
    }
}
```

配置redaccount数据源的sessionFactory
``` 
@Configuration
@MapperScan(basePackages = {"com.agan.boot.mapper.redaccount.mapper"}, sqlSessionFactoryRef = "redPacketSqlSessionFactory")
public class RedAccountDataSourceConfiguration {
    /**
     * mybatis的xml文件.
     */
    public static final String MAPPER_XML_LOCATION = "classpath*:com/agan/boot/mapper/redaccount/mapper/*.xml";


    @Autowired
    @Qualifier("RedPacketDataSource")
    DataSource redPacketDataSource;

    /**
     * 配置Sql Session模板
     */
    @Bean
    public SqlSessionTemplate redPacketSqlSessionTemplate() throws Exception {
        return new SqlSessionTemplate(redPacketSqlSessionFactory());
    }

    /**
     * 配置SQL Session工厂
     */
    @Bean
    public SqlSessionFactory redPacketSqlSessionFactory() throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(redPacketDataSource);
        factoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(MAPPER_XML_LOCATION));
        return factoryBean.getObject();
    }

    /**
     *  配置事务
     */
    @Bean(name="transactionManager")
    public DataSourceTransactionManager transactionManager(){
        return new DataSourceTransactionManager(redPacketDataSource);
    }
}
```
## 步骤5：生成account表和 redpacket表对应的mybatis文件
采用mybatis-generator来自动生成代码，具体见《MyBatis 代码生成器Generator》

## 步骤6：service 体验类 
PayService 作用：模拟发红包，账户余额减钱，红包余额加钱
``` 

@Service
public class PayService {

    @Autowired
    private CapitalAccountMapper capitalAccountMapper;
    @Autowired
    private RedPacketAccountMapper redPacketAccountMapper;

    /**
     * 账户余额 减钱
     * @param userId
     * @param account
     */
    @Transactional(rollbackFor = Exception.class)
    public void payAccount(int userId,int account) {
        CapitalAccount ca=new CapitalAccount();
        ca.setUserId(userId);
        CapitalAccount capitalDTO=this.capitalAccountMapper.selectOne(ca);
//        System.out.println(capitalDTO);
        //从账户里面扣除钱
        capitalDTO.setBalanceAmount(capitalDTO.getBalanceAmount()-account);
        this.capitalAccountMapper.updateByPrimaryKey(capitalDTO);

    }

    /**
     * 红包余额 加钱
     * @param userId
     * @param account
     */
    @Transactional(rollbackFor = Exception.class)
    public void payRedPacket(int userId,int account) {
        RedPacketAccount red= new RedPacketAccount();
        red.setUserId(userId);
        RedPacketAccount redDTO=this.redPacketAccountMapper.selectOne(red);
//        System.out.println(redDTO);
        //红包余额 加钱
        redDTO.setBalanceAmount(redDTO.getBalanceAmount()+account);
        this.redPacketAccountMapper.updateByPrimaryKey(redDTO);

        //int i=9/0;
    }

    @Transactional(rollbackFor = Exception.class)
    public void pay(int fromUserId,int toUserId,int account){
        //账户余额 减钱
        this.payAccount(fromUserId,account);
        //红包余额 加钱
        this.payRedPacket(toUserId,account);
    }
}

```

## 步骤7：controller测试体验类
``` 

@RestController
public class PayController {

    @Autowired
    private PayService payService;

    @RequestMapping(value = "/pay", method = RequestMethod.GET)
    public void create(){
        this.payService.pay(1,2,10);
    }

}
```

 @Configuration、@ConfigurationProperties、@Bean、@Qualifier注解:

@Configuration 作为 Spring对Bean的显示配置，用于构建bean的定义。

官方解析：@Configuration用于定义配置类，可替换xml配置文件，被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。

@ConfigurationProperties 是对"@Configuration"注解类的属性配置说明。如：@ConfigurationProperties(prefix="spring.datasource.druid.account")。这样该注解类的属性就可以配置在文件中，如以上类“KNApiProviderConfig”的属性可以在application.xml配置。

理解：

1 就是就是把application.properties配置信息和Bean为AccountDataSource类绑定起来

spring.datasource.druid.account.username=root
spring.datasource.druid.account.password=123
spring.datasource.druid.account.driver-class-name=com.mysql.jdbc.Driver
@Configuration
@EnableConfigurationProperties
@EnableTransactionManagement(proxyTargetClass = true)
public class MybatisConfiguration {
    /**
     * account数据库配置前缀.
     */
    final static String ACCOUNT_PREFIX = "spring.datasource.druid.account";
    /**
     * redpacket数据库配置前缀.
     */
    final static String REDPACKET_PREFIX = "spring.datasource.druid.redpacket";

    /**
     * 配置Account数据库的数据源
     *
     * @return the data source
     */
    @Bean(name = "AccountDataSource")
    @ConfigurationProperties(prefix = ACCOUNT_PREFIX)  // application.properties中对应属性的前缀
    public DataSource accountDataSource() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 配置RedPacket数据库的数据源
     *
     * @return the data source
     */
    @Bean(name = "RedPacketDataSource")
    @ConfigurationProperties(prefix = REDPACKET_PREFIX)  // application.properties中对应属性的前缀
    public DataSource redPacketDataSource() {
        return DruidDataSourceBuilder.create().build();
    }
}

2 @Qualifier 对Bean的命名.就是使用这个类

@Configuration
@MapperScan(basePackages = {"com.agan.boot.mapper.account.mapper"}, sqlSessionFactoryRef = "accountSqlSessionFactory")
public class AccountDataSourceConfiguration {
    /**
     * mybatis的xml文件.
     */
    public static final String MAPPER_XML_LOCATION = "classpath*:com/agan/boot/mapper/account/mapper/*.xml";

    @Autowired
    @Qualifier("AccountDataSource")
    DataSource accountDataSource;

集成mybatis攻略

# SpringBoot集成mybatis攻略

## 一、课程目标：
1. 为什么使用 MyBatis ？
2. 为什么需要通用的tk mapper ?
3. 感受《MyBatis 代码生成器Generator》自动生成代码的快感
4. 体验不用写SQL的mybatis通用增删改查操作

## 一、什么是 MyBatis？
MyBatis 是一款优秀的持久层框架，支持常规的SQL查询，同时也支持定制化SQL、存储过程以及高级映射。
MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。
MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。


## 二、为什么使用 MyBatis
在我们传统的 JDBC 中，我们除了需要自己提供 SQL 外，还必须操作 Connection、Statment、ResultSet，不仅如此，为了访问不同的表，不同字段的数据，
我们需要些很多雷同模板化的代码，即繁琐又枯燥。
而我们在使用了 MyBatis 之后，只需要提供 SQL 语句就好了，其余的诸如：建立连接、操作 Statment、ResultSet，处理 JDBC 相关异常等等都可以交给
 MyBatis 去处理，我们的关注点于是可以就此集中在 SQL 语句上，关注在增删改查这些操作层面上。
并且 MyBatis 支持使用简单的 XML 或注解来配置和映射原生信息，
将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。

一句话：不用写jdbc代码，只写sql就行！！！

## 四、什么是通用的tk mapper ?
在使用MyBatis 的同时，建议大家再搭配使用"通用tk Mapper4"，它是一个可以实现任意 MyBatis 通用方法的框架，
项目提供了常规的增删改查操作以及Example 相关的单表操作。通用 Mapper 是为了解决 MyBatis 使用中 90% 的基本操作，
使用它可以很方便的进行开发，可以节省开发人员大量的时间。
官方地址：https://github.com/abel533/Mapper/wiki

## 三、那为什么需要通用的tk mapper ?
mybatis最大的一个问题，就是要写大量的SQL在XML中，因为除了必须的特殊复杂的业务逻辑SQL外，还要为大量的类似增删改查SQL。
另外，当数据库表结构变更时，所有对应的SQL和实体类都要改一遍，那个痛苦啊。故，通用tk mapper应运而生。

一句话：不用写jdbc代码，同时也不用写sql ！（对于互联网公司来说，97%不是写sql,剩下3%要写多表关联查询sql）

## 四、案例实战：SpringBoot配置mybatis的步骤 
### 步骤1：pom文件引入依赖包
``` 



    tk.mybatis
    mapper-spring-boot-starter
    2.0.3



    mysql
    mysql-connector-java



    org.projectlombok
    lombok
    1.18.8

```
### 步骤2：采用mybatis-generator自动生成代码
拷贝《案例实战：MyBatis 代码生成器Generator》生成的代码即可

### 步骤3：application.properties 加入mysql配置信息
``` 
#指定mapper.xml的位置
mybatis.mapper-locations=classpath*:com/agan/boot/mapper/xml/*.xml

#数据库驱动和ip
spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.0.138:3308/boot_user?useUnicode=true&characterEncoding=UTF-8&zeroDateTimeBehavior=convertToNull
spring.datasource.username=root
spring.datasource.password=agan
```
特别注意：一定要配置mybatis.mapper-locations mybatis的xml路径，不然启动不了！！！

### 步骤4：配置扫描mapper类的路径包 
在启动类中，加入mybatis的mapper
@MapperScan("com.agan.boot.mapper")
如果不配的话，mybatis找不到UserMapper文件
``` 
//指定要扫描的Mapper类的包的路径
@MapperScan("com.agan.boot.mapper")
@SpringBootApplication
public class MybatisApplication {

    public static void main(String[] args) {
        SpringApplication.run(MybatisApplication.class, args);
    }

}
```
### 步骤5：测试类
UserController

Controller

@RestController
@RequestMapping("/user")
public class UserController {


    @Autowired
    private UserService userService;

    /**
     * 初始化1000条数据
     */
    @RequestMapping(value = "/c", method = RequestMethod.GET)
    public void create(){
        for(int i=0;i<1000;i++){
            User user=new User();
            String temp="user"+i;
            user.setUsername(temp);
            user.setPassword(temp);
            Random random=new Random();
            int sex=random.nextInt(2);
            user.setSex((byte)sex);
            userService.createUser(user);
        }
    }

    /**
     * 修改某条数据
     * @param id
     */
    @RequestMapping(value = "/u/{id}", method = RequestMethod.GET)
    public void create(@PathVariable  int id){
        User user=new User();
        user.setId(id);
        String temp="update"+id;
        user.setUsername(temp);
        user.setPassword(temp);
        this.userService.updateUser(user);
    }

    /**
     * 查询例子
     */
    @RequestMapping(value = "/f", method = RequestMethod.GET)
    public void find(){
        this.userService.findExample();
    }

}

Service

@Service
@Slf4j
public class UserService {

    @Autowired
    private UserMapper userMapper;


    public void createUser(User obj){
        userMapper.insertSelective(obj);
    }

    public void updateUser(User obj){
        this.userMapper.updateByPrimaryKeySelective(obj);
    }

    public void findExample(){
        log.info("----------------按主键查询： where id=100----------------");
        User user=this.userMapper.selectByPrimaryKey(100);
        log.info(user.toString());

        log.info("----------------查询： where sex=1----------------");
        User sex=new User();
        sex.setSex((byte)1);
        List list=this.userMapper.select(sex);
        log.info("查询sex=1的条数，{}",list.size());

        log.info("----------------查询： where username=? and password=?----------------");
        User user1=new User();
        user1.setUsername("update100");
        user1.setPassword("update100");
        User obj=this.userMapper.selectOne(user1);
        log.info(obj.toString());

        /**
         * 复杂查询用Example.Criteria
         */

        log.info("----------------Example.Criteria查询： where username=? and password=?----------------");
        Example example=new Example(User.class);
        Example.Criteria criteria=example.createCriteria();
        criteria.andEqualTo("username","update100");
        criteria.andEqualTo("password","update100");
        List objs=this.userMapper.selectByExample(example);
        log.info("Example.Criteria查询结果，{}",objs.toString());


        log.info("----------------Example.Criteria 模糊查询： where username like ? ----------------");
        example=new Example(User.class);
        criteria=example.createCriteria();
        criteria.andLike("username","%100%");
        objs=this.userMapper.selectByExample(example);
        log.info("Example.Criteria查询结果，{}",objs.toString());


        log.info("----------------Example.Criteria 排序： where username like ? order by id desc ----------------");
        example=new Example(User.class);
        example.setOrderByClause("id desc ");
        criteria=example.createCriteria();
        criteria.andLike("username","%100%");
        objs=this.userMapper.selectByExample(example);
        log.info("Example.Criteria查询结果，{}",objs.toString());


        log.info("----------------Example.Criteria in 查询： where id  in (1,2) ----------------");
        example=new Example(User.class);
        criteria=example.createCriteria();
        List ids=new ArrayList();
        ids.add(1);
        ids.add(2);
        criteria.andIn("id",ids);
        objs=this.userMapper.selectByExample(example);
        log.info("Example.Criteria查询结果，{}",objs.toString());




        log.info("----------------分页查询1----------------");
        User obj2=new User();
        obj2.setSex((byte)1);
        int count=this.userMapper.selectCount(obj2);
        log.info("分页例子：总条数{}",count);
        objs=this.userMapper.selectByRowBounds(obj2,new RowBounds(0,10));
        for (User u:objs){
            log.info("分页例子：第一页{}",u.toString());
        }

        log.info("----------------Example.Criteria分页查询2----------------");
        example=new Example(User.class);
        criteria=example.createCriteria();
        criteria.andEqualTo("sex",1);
        count=this.userMapper.selectCountByExample(example);
        log.info("分页例子：总条数{}",count);

        objs=this.userMapper.selectByExampleAndRowBounds(example,new RowBounds(0,10));
        for (User u:objs){
            log.info("分页例子：第一页{}",u.toString());
        }


    }


}

guava限流库(本意：番石榴)

推荐使用aop切面拦截+注解引入使用


### 本课程目标：
1.弄懂为什么要限流，学会限流的技巧。
2.了解限流的令牌桶算法
3.编码实现guava的SpringBoot限流
4.为了提升开发效率，降低代码耦合度，采用自定义注解来实现接口限流

### 互联网系统为什么要限流？
因为互联网系统通常都要面对大并发大流量的请求，在突发情况下，系统是抗不住的，例如，抢票系统 12306,在面对高并发的情况下，就是采用了限流。
例如：12306限流后，就进入了服务降级，在流量高峰期间经常会出现,这的提示语；"当前排队人数较多，请稍后再试！"
故，针对高并发流量来说，限流是最好的保护机制。

### 那什么是限流？如何实现？
限流是对某一时间窗口内的请求数进行限制，保持系统的可用性和稳定性，防止因流量暴增而导致的系统运行缓慢或宕机。
Google开源工具包Guava提供了限流工具类RateLimiter，该类基于令牌桶算法实现流量限制，使用十分方便，而且十分高效。

### 重点讲解令牌桶算法
令牌算法：
假设有一个木桶，这个木桶干了2件事：
1.系统按恒定1/QPS的时间顺序，往桶里放入令牌token;如果桶加满了就不加。
2.当新请求过来时，会在桶里拿走一个token,如果没有token可以拿，就阻塞或拒绝服务。
![image](https://github.com/agan-java/images/blob/master/limiter/01.png?raw=true)
![image](https://github.com/agan-java/images/blob/master/limiter/02.jpg?raw=true)
### 采用guava实现SpringBoot限流
#### 步骤1：pom文件加入guava依赖包
```

    com.google.guava
    guava
    28.1-jre

```
#### 步骤2：加入限流逻辑
```
@RestController
@Slf4j
public class TestController {

    //限流，1秒钟2个
    private RateLimiter limiter = RateLimiter.create(2);

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @GetMapping("/limiter")
    public String testLimiter() {
        //500毫秒内，没拿到令牌，就直接进入服务降级
        boolean tryAcquire = limiter.tryAcquire(500, TimeUnit.MILLISECONDS);
        if (!tryAcquire) {
            log.warn("进入服务降级，时间{}", simpleDateFormat.format(new Date()));
            return "当前排队人数较多，请稍后再试！";
        }
        log.info("获取令牌成功，时间{}", simpleDateFormat.format(new Date()));
        return "success";
    }
}
```
以上用到了RateLimiter的2个核心方法：create()、tryAcquire()，以下详细说明
- acquire()	             获取一个令牌, 改方法会阻塞直到获取到这一个令牌, 返回值为获取到这个令牌花费的时间
- acquire(int permits)	 获取指定数量的令牌, 该方法也会阻塞, 返回值为获取到这 N 个令牌花费的时间
- tryAcquire()	         判断时候能获取到令牌, 如果不能获取立即返回 false
- tryAcquire(int permits)	获取指定数量的令牌, 如果不能获取立即返回 false
- tryAcquire(long timeout, TimeUnit unit)	判断能否在指定时间内获取到令牌, 如果不能获取立即返回 false
- tryAcquire(int permits, long timeout, TimeUnit unit)	同上

#### 步骤3：体验效果
浏览器反复刷新，此测试地址： http://127.0.0.1:9090/limiter
```
 进入服务降级，时间2019-09-24 18:17:59
 获取令牌成功，时间2019-09-24 18:17:59
 进入服务降级，时间2019-09-24 18:17:59
 进入服务降级，时间2019-09-24 18:17:59
 获取令牌成功，时间2019-09-24 18:17:59
 进入服务降级，时间2019-09-24 18:17:59

 进入服务降级，时间2019-09-24 18:18:00
 获取令牌成功，时间2019-09-24 18:18:00
 进入服务降级，时间2019-09-24 18:18:00
 进入服务降级，时间2019-09-24 18:18:00
 获取令牌成功，时间2019-09-24 18:18:00
```
从以上日志可以看出，1秒钟内只有2次成功，其他都失败降级了。

### 启用自定义注解实现接口限流
为什么要自定义注解来实现接口限流？
1. 业务代码和限流代码解耦，开发人员只要一个注解，不用关心限流的实现逻辑。
1. 采用实现自定义注解，减少代码冗余。
#### 步骤1：pom文件加入aop依赖包
```

    org.springframework.boot
    spring-boot-starter-aop

```
#### 步骤2：实现一个限流自定义注解
```

```
#### 步骤3：用切面拦截限流注解
```

```
#### 步骤3：实现限流接口
```
@GetMapping("/limiter2")
@Limiter(key = "limiter2", permitsPerSecond = 1, timeout = 500, timeunit = TimeUnit.MILLISECONDS,msg = "当前排队人数较多，请稍后再试！")
public String limiter2() {
    log.debug("令牌桶=limiter2，获取令牌成功");
    return "ok";
}

@GetMapping("/limiter3")
@Limiter(key = "limiter3", permitsPerSecond = 2, timeout = 500, timeunit = TimeUnit.MILLISECONDS,msg = "当前排队人数较多，请稍后再试！")
public String limiter3() {
    log.debug("令牌桶=limiter3，获取令牌成功");
    return "ok";
}
```
##：课后练习
guava 的RateLimiter提供了2个方法tryAcquire()和acquire()来实现限流；
我们本课程采用的是tryAcquire()来实现限流，如果采用 acquire()，会怎么样？ 请编码实现。

@RestController与@Controller

1 使用@Controller时需要用@ResponseBody注释.

Spring 3.x 或使用@Controller情况下，在方法上使用@ResponseBody注释时，Spring会转换返回值并自动将其写入HTTP响应。Controller类中的每个方法都必须使用@ResponseBody进行注释。


@Controller
@RequestMapping("employees")
public class EmployeeController {
    Employee employee = new Employee();
    @RequestMapping(value = "/{name}", method = RequestMethod.GET, produces = "application/json")
    public @ResponseBody Employee getEmployeeInJSON(@PathVariable String name) {
       employee.setName(name);
       employee.setEmail("[email protected]");
    return employee; 
    }

    @RequestMapping(value = "/{name}.xml", method = RequestMethod.GET, produces = "application/xml")
    public @ResponseBody Employee getEmployeeInXML(@PathVariable String name) {
       employee.setName(name);
     employee.setEmail("[email protected]");
       return employee; 
    }
}

2 @RestController自动添加@Controller和@ResponseBody注释

Spring 4.0引入了@RestController，这是一个控制器的专用版本，它是一个方便的注释，除了自动添加@Controller和@ResponseBody注释之外没有其他新魔法。

使用@RestController非常简单，这是从Spring v4.0开始创建MVC RESTful Web服务或基于SpringBoot 2的首选方法。

@RestController
public class EmployeeController {

    Employee employee = new Employee();

    @GetMapping("/employees/{name}")
    public Employee getEmployeeInJSON(@PathVariable("name") String name) {
       employee.setName(name);
       employee.setEmail("[email protected]");
       return employee;
    }
 
}

Controller的response做统一格式封装

#response统一格式
##一、本课程目标：
1. 弄清楚为什么要对springboot,所有Controller的response做统一格式封装？
1. 学会用ResponseBodyAdvice接口 和 @ControllerAdvice注解

##二、为什么要对springboot的接口返回值统一标准格式?
我们先来看下，springboot默认情况下的response是什么格式的
###第一种格式：response为String 
``` 
@GetMapping(value="/getStr")
public String  getStr(  ){
    return  "test";
}
```
以上springboot的返回值为
``` 
test
```
###第二种格式：response为Objct 
``` 
@GetMapping(value="/getObject")
public UserVO  getObject(  ){
    UserVO vo=new UserVO();
    vo.setUsername("agan");
    return  vo;
}
```
以上springboot的返回值为
``` 
{
  "id": null,
  "username": "agan",
  "password": null,
  "email": null,
  "phone": null,
  "idCard": null,
  "sex": null,
  "deleted": null,
  "updateTime": null,
  "createTime": null
}
```
###第三种格式：response为void 
``` 
@GetMapping(value="/empty")
public void  empty(  ){

}
```
以上springboot的返回值为空

###第四种格式：response为异常 
``` 
@GetMapping(value="/error")
public void  error(  ){
    int i=9/0;
}
```
以上springboot的返回值为空
``` 
{
  "timestamp": "2019-09-07T10:35:56.658+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "/ by zero",
  "path": "/user/error"
} 
```
以上3种，情况，如果你和客户端（app h5）开发人联调接口，他们会很懵逼，因为你给他们的接口没有一个统一的格式，客户端开发人员，不知道如何处理返回值。
故，我们应该统一response的标准格式。

##三、定义response的标准格式
一般的response的标准格式包含3部分：
1.status状态值：代表本次请求response的状态结果。
2.response描述：对本次状态码的描述。
3.data数据：本次返回的数据。
``` 
{
   "status":0,
   "desc":"成功",
   "data":"test"
}
```
##四、初级程序员对response代码封装
对response的统一封装，是有一定的技术含量的，我们先来看下，初级程序员的封装，网上很多教程都是这么写的。
### 步骤1:把标准格式转换为代码
``` 
{
   "status":0,
   "desc":"成功",
   "data":"test"
}
```
把以上格式转换为Result代码

``` 

@AllArgsConstructor
@NoArgsConstructor
@Data
public class Result {
    /**
     * 1.status状态值：代表本次请求response的状态结果。
     */
    private Integer status;
    /**
     * 2.response描述：对本次状态码的描述。
     */
    private String desc;
    /**
     * 3.data数据：本次返回的数据。
     */
    private T data;

    /**
     * 成功，创建ResResult：没data数据
     */
    public static Result suc() {
        Result result = new Result();
        result.setResultCode(ResultCode.SUCCESS);
        return result;
    }

    /**
     * 成功，创建ResResult：有data数据
     */
    public static Result suc(Object data) {
        Result result = new Result();
        result.setResultCode(ResultCode.SUCCESS);
        result.setData(data);
        return result;
    }

    /**
     * 失败，指定status、desc
     */
    public static Result fail(Integer status, String desc) {
        Result result = new Result();
        result.setStatus(status);
        result.setDesc(desc);
        return result;
    }

    /**
     * 失败，指定ResultCode枚举
     */
    public static Result fail(ResultCode resultCode) {
        Result result = new Result();
        result.setResultCode(resultCode);
        return result;
    }

    /**
     * 把ResultCode枚举转换为ResResult
     */
    private void setResultCode(ResultCode code) {
        this.status = code.code();
        this.desc = code.message();
    }
}
```
### 步骤2:把状态码存在枚举类里面
``` 

public enum ResultCode  {

	/* 成功状态码 */
	SUCCESS(0, "成功"),

	/* 系统500错误*/
	SYSTEM_ERROR(10000, "系统异常，请稍后重试"),
	UNAUTHORIZED(10401, "签名验证失败"),

	/* 参数错误：10001-19999 */
	PARAM_IS_INVALID(10001, "参数无效"),

	/* 用户错误：20001-29999*/
	USER_HAS_EXISTED(20001, "用户名已存在"),
	USER_NOT_FIND(20002, "用户名不存在");
	private Integer code;

	private String message;

	ResultCode(Integer code, String message) {
		this.code = code;
		this.message = message;
	}

	public Integer code() {
		return this.code;
	}

	public String message() {
		return this.message;
	}

}
```

### 步骤3:加一个体验类
``` 
@Api(description = "用户接口")
@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

    @GetMapping(value="/getResult")
    public Result getResult(  ){
        return Result.suc("test");
    }
}

```
结论：看到这里，应该有很多同学都知道这样封装代码有很大弊端。
因为今后你每写一个接口，都要手工指定Result.suc(）这行代码，多累啊？？
如果你写这种代码推广给你整个公司用，然后硬性规定代码必须这么写！！所有程序都会吐槽鄙视！！！！



##五、高级程序员对response代码封装
如果你在公司推广你的编码规范，为了避免被公司其他程序员吐槽和鄙视，我们必须优化代码。
优化的目标：不要每个接口都手工指定Result返回值。

###步骤1：采用ResponseBodyAdvice技术来实现response的统一格式
springboot提供了ResponseBodyAdvice来帮我们处理
ResponseBodyAdvice的作用：拦截Controller方法的返回值，统一处理返回值/响应体，一般用来做response的统一格式、加解密、签名等等。
先看下ResponseBodyAdvice这个接口的源码。

``` 
public interface ResponseBodyAdvice {
    /**
     * 是否支持advice功能
     * treu=支持，false=不支持
     */
    boolean supports(MethodParameter var1, Class> var2);
    /**
     *
     * 处理response的具体业务方法
     */
    @Nullable
    T beforeBodyWrite(@Nullable T var1, MethodParameter var2, MediaType var3, Class> var4, ServerHttpRequest var5, ServerHttpResponse var6);
}

```
###步骤2：写一个ResponseBodyAdvice实现类
``` 
@ControllerAdvice(basePackages = "com.agan.boot")
public class ResponseHandler implements ResponseBodyAdvice {

    /**
     * 是否支持advice功能
     * treu=支持，false=不支持
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Class> aClass) {
        return true;
    }

    /**
     *
     * 处理response的具体业务方法
     */
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        if (o instanceof String) {
            return JsonUtil.object2Json(Result.suc(o));
        }
        return Result.suc(o);
    }
}

```

以上代码，有2个地方需要重点讲解：
#### 第1个地方：@ControllerAdvice 注解：
@ControllerAdvice这是一个非常有用的注解，它的作用是增强Controller的扩展功能类。
那@ControllerAdvice对Controller增强了哪些扩展功能呢？主要体现在2方面：
1. 对Controller全局数据统一处理，例如，我们这节课就是对response统一封装。
1. 对Controller全局异常统一处理，这个后面的课程会详细讲解。

在使用@ControllerAdvice时，还要特别注意，加上basePackages,
@ControllerAdvice(basePackages = "com.agan.boot"),因为如果不加的话，它可是对整个系统的Controller做了扩展功能，
它会对某些特殊功能产生冲突，例如 不加的话，在使用swagger时会出现空白页异常。


#### 第2个地方：beforeBodyWrite方法体的response类型判断
``` 
if (o instanceof String) {
            return JsonUtil.object2Json(ResResult.suc(o));
}
```
以上代码一定要加，因为Controller的返回值为String的时候，它是直接返回String,不是json，
故我们要手工做下json转换处理



##六：课后练习题
本节课，我们没有对Controller的异常做处理，是会出问题的。
在本节课的基础上执行以下代码：
``` 
@GetMapping(value="/error")
public void  error(){
    int i=9/0;
}
```
自己体验下，会出什么问题？ 然后思考怎么解决？

 
  
代码
 
  
@ControllerAdvice(basePackages = "com.agan.boot")
public class ResponseHandler implements ResponseBodyAdvice {

    /**
     * 是否支持advice功能
     * treu=支持，false=不支持
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Class> aClass) {
        return true;
    }

    /**
     *
     * 处理response的具体业务方法
     */
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
     if (o instanceof String) {
            return JsonUtil.object2Json(Result.suc(o));
        }
        return Result.suc(o);
    }
} 
  
@ControllerAdvice
 
  
以上代码，有2个地方需要重点讲解：
 #### 第1个地方：@ControllerAdvice 注解：
 @ControllerAdvice这是一个非常有用的注解，它的作用是增强Controller的扩展功能类。
 那@ControllerAdvice对Controller增强了哪些扩展功能呢？主要体现在2方面：
 1. 对Controller全局数据统一处理，例如，我们这节课就是对response统一封装。
 1. 对Controller全局异常统一处理，这个后面的课程会详细讲解。
 
  
在使用@ControllerAdvice时，还要特别注意，加上basePackages,
 @ControllerAdvice(basePackages = "com.agan.boot"),因为如果不加的话，它可是对整个系统的Controller做了扩展功能，
 它会对某些特殊功能产生冲突，例如 不加的话，在使用swagger时会出现空白页异常。
 
  

 #### 第2个地方：beforeBodyWrite方法体的response类型判断

 以上代码一定要加，因为Controller的返回值为String的时候，它是直接返回String,不是json，
 故我们要手工做下json转换处理
 
  
if (o instanceof String) {
            return JsonUtil.object2Json(ResResult.suc(o));
}
 
  
全局异常处理器Exception
 
  
##一、本课程目标：
1. 弄懂为什么springboot需要《全局异常处理器》？
2. 编码实战一个springboot《全局异常处理器》
3. 封装一个自定义异常 ，并集成进《局异常处理器》
4. 把《全局异常处理器》集成进《接口返回值统一标准格式》


## 二、springboot为什么需要全局异常处理器？
1. 先讲下什么是全局异常处理器？

全局异常处理器就是把整个系统的异常统一自动处理，程序员可以做到不用写try...catch
2. 那为什么需要全局异常呢？
- 第一个原因：不用强制写try-catch,由全局异常处理器统一捕获处理
``` 
    @PostMapping(value="/error1")
    public void  error1(  ){
        int i=9/0;
    }

```
如果不用try-catch捕获的话，客户端就会怎么样？
``` 
{
  "timestamp": "2019-10-02T02:15:26.591+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "/ by zero",
  "path": "/user/error1"
}
```
这种格式对于客户端来说，不友好，而一般程序员的try-catch
``` 
    @PostMapping(value="/error11")
    public String  error11(  ){
        try{
            int i=9/0;
        }catch (Exception ex){
            log.error("异常：{}",ex);
            return "no";
        }
        return "ok";
    }
```
但是还要一直自动化处理的，就是不用谢try-catch，由全局异常处理器来处理。

- 第二个原因：自定义异常，只能用全局异常来捕获。
``` 
    @PostMapping(value="/error4")
    public void  error4(  ){
        throw new RuntimeException("用户已存在！！");
    }

```

``` 
{
  "timestamp": "2019-10-02T02:18:26.843+0000",
  "status": 500,
  "error": "Internal Server Error",
  "message": "用户已存在！！",
  "path": "/user/error4"
}
```
不可能这样直接返回给客户端，客户端是看不懂的，而且需要接入进《接口返回值统一标准格式》

- 第三个原因：JSR303规范的Validator参数校验器，参数校验不通过会抛异常，是无法使用try-catch语句直接捕获，
只能使用全局异常处理器了，JSR303规范的Validator参数校验器的异常处理后面课程会单独讲解，本节课暂不讲解。

## 三、案例实战：编码实现一个springboot《全局异常处理器》
### 步骤1：封装异常内容，统一存储在枚举类中
把所有的未知运行是异常都，用SYSTEM_ERROR(10000, "系统异常，请稍后重试")来提示
``` 
public enum ResultCode  {

	/* 成功状态码 */
	SUCCESS(0, "成功"),

	/* 系统500错误*/
	SYSTEM_ERROR(10000, "系统异常，请稍后重试"),
	UNAUTHORIZED(10401, "签名验证失败"),

	/* 参数错误：10001-19999 */
	PARAM_IS_INVALID(10001, "参数无效"),

	/* 用户错误：20001-29999*/
	USER_HAS_EXISTED(20001, "用户名已存在"),
	USER_NOT_FIND(20002, "用户名不存在");
	private Integer code;

	private String message;

	ResultCode(Integer code, String message) {
		this.code = code;
		this.message = message;
	}

	public Integer code() {
		return this.code;
	}

	public String message() {
		return this.message;
	}

}
```
### 步骤2：封装Controller的异常结果
最终目标格式：
``` 
{
  "status": 10000,
  "message": "系统异常，请稍后重试",
  "exception": "java.lang.ArithmeticException"
}
```

``` 
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Data
public class ErrorResult {

	/**
	 * 异常状态码
	 */
	private Integer status;

	/**
	 * 用户看得见的异常，例如 用户名重复！！,
	 */
	private String message;

	/**
	 * 异常的名字
	 */
	private String exception;

	/**
	 * 异常堆栈信息
	 */
	//private String errors;

	/**
	 * 对异常提示语进行封装
	 */
	public static ErrorResult fail(ResultCode resultCode, Throwable e,String message) {
		ErrorResult result = ErrorResult.fail(resultCode, e);
		result.setMessage(message);
		return result;
	}

	/**
	 * 对异常枚举进行封装
	 */
	public static ErrorResult fail(ResultCode resultCode, Throwable e) {

		ErrorResult result = new ErrorResult();
		result.setMessage(resultCode.message());
		result.setStatus(resultCode.code());
		result.setException(e.getClass().getName());
		//result.setErrors(Throwables.getStackTraceAsString(e));
		return result;
	}
}
```

### 步骤3：加个全局异常处理器，对异常进行处理
``` 
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler  {
    /**
     * 处理运行时异常
     */
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Throwable.class)
    public ErrorResult handleThrowable(Throwable e, HttpServletRequest request) {
        //TODO 运行是异常，可以在这里记录，用于发异常邮件通知
        ErrorResult error =ErrorResult.fail(ResultCode.SYSTEM_ERROR, e);
        log.error("URL:{} ,系统异常: ",request.getRequestURI(), e);
        return error;
    }
}

```
handleThrowable方法的作用是：捕获运行时异常，并把异常统一封装为ErrorResult对象。
以上有几个细节点我们要单独讲解：
1. @RestControllerAdvice在《接口返回值统一标准格式》课程的时候，我们就讲解过它是增强Controller的扩展功能。而全局异常处理器，就是扩展功能之一。
2. @ExceptionHandler统一处理某一类异常，从而能够减少代码重复率和复杂度，@ExceptionHandler(Throwable.class)指处理Throwable的异常。
3. @ResponseStatus指定客户端收到的http状态码，这里配置500错误，客户端就显示500错误，

### 步骤4：体验效果
``` 
    @PostMapping(value="/error1")
    public void  error1(  ){
        int i=9/0;
    }
```
结果
``` 
{
  "status": 10000,
  "message": "系统异常，请稍后重试",
  "exception": "java.lang.ArithmeticException"
}
```

## 三、案例实战：把自定义异常 集成 进《全局异常处理器》

### 步骤1：封装一个自定义异常

自定义异常通常是集成RuntimeException
``` 
@Data
public class BusinessException extends RuntimeException {

	protected Integer code;

	protected String message;


	public BusinessException(ResultCode resultCode) {
		this.code = resultCode.code();
		this.message = resultCode.message();
	}

}
```

### 步骤2：把自定义异常 集成 进全局异常处理器
全局异常处理器只要在上节课的基础上，添加一个自定义异常处理即可。
``` 
	/**
     * 处理自定义异常
     */
	@ExceptionHandler(BusinessException.class)
	public ErrorResult handleBusinessException(BusinessException e, HttpServletRequest request) {
        ErrorResult error = ErrorResult.builder().status(e.code)
                .message(e.message)
                .exception(e.getClass().getName())
                .build();
        log.warn("URL:{} ,业务异常:{}", request.getRequestURI(),error);
        return error;
	}
```
### 步骤3：体验效果
``` 
    @PostMapping(value="/error3")
    public void  error3(  ){
        throw new BusinessException(ResultCode.USER_HAS_EXISTED);
    }
```
结果
``` 
{
  "status": 20001,
  "message": "用户名已存在",
  "exception": "com.agan.boot.exceptions.BusinessException"
}
```

## 四、案例实战：把《全局异常处理器》集成进《接口返回值统一标准格式》
目标：把《全局异常处理器》的json格式转换为《接口返回值统一标准格式》格式
``` 
{
  "status": 20001,
  "message": "用户名已存在",
  "exception": "com.agan.boot.exceptions.BusinessException"
}
```
转换
``` 
{
   "status":20001,
   "desc":"用户名已存在",
   "data":null
}
```
### 步骤1：改造ResponseHandler
``` 

@ControllerAdvice(basePackages = "com.agan.boot")
public class ResponseHandler implements ResponseBodyAdvice {

    /**
     * 是否支持advice功能
     * treu=支持，false=不支持
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Class> aClass) {
        return true;
    }

    /**
     *
     * 处理response的具体业务方法
     */
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        if (o instanceof ErrorResult) {
            ErrorResult errorResult = (ErrorResult) o;
            return Result.fail(errorResult.getStatus(),errorResult.getMessage());
        } else if (o instanceof String) {
            return JsonUtil.object2Json(Result.suc(o));
        }
        return Result.suc(o);
    }
}

```
在 《接口返回值统一标准格式》的基础上
``` 
 if (o instanceof ErrorResult) {
            ErrorResult errorResult = (ErrorResult) o;
            return Result.fail(errorResult.getStatus(),errorResult.getMessage());
}
```

### 步骤2：体验效果
``` 
    @PostMapping(value="/error3")
    public void  error3(  ){
        throw new BusinessException(ResultCode.USER_HAS_EXISTED);
    }
```
结果
``` 
{
  "status": 20001,
  "desc": "用户名已存在",
  "data": null
}
```

##六：课后练习题
自己手写一个《全局异常处理器》和《接口返回值统一标准格式》

1.模拟一个空指针异常，然后返回以下接口返回值统一标准格式：
``` 
{
  "code": 10000,
  "msg": "系统异常请稍后...",
  "data": null
}
```
2.模拟用户登录，自定义异常，提示以下内容
``` 
{
  "code": 20003,
  "msg": "用户名或密码错误，请重试",
  "data": null
}
```
 
  
细节点+@RestControllerAdvice+@ExceptionHandler
 
  
### 步骤3：加个全局异常处理器，对异常进行处理
 handleThrowable方法的作用是：捕获运行时异常，并把异常统一封装为ErrorResult对象。
 以上有几个细节点我们要单独讲解：
 1. @RestControllerAdvice在《接口返回值统一标准格式》课程的时候，我们就讲解过它是增强Controller的扩展功能。而全局异常处理器，就是扩展功能之一。
 2. @ExceptionHandler统一处理某一类异常，从而能够减少代码重复率和复杂度，@ExceptionHandler(Throwable.class)指处理Throwable的异常。
 3. @ResponseStatus指定客户端收到的http状态码，这里配置500错误，客户端就显示500错误，
 
  
@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler  {
    /**
     * 处理运行时异常
     */
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    @ExceptionHandler(Throwable.class)
    public ErrorResult handleThrowable(Throwable e, HttpServletRequest request) {
        //TODO 运行是异常，可以在这里记录，用于发异常邮件通知
        ErrorResult error =ErrorResult.fail(ResultCode.SYSTEM_ERROR, e);
        log.error("URL:{} ,系统异常: ",request.getRequestURI(), e);
        return error;
    }
}
 
  
validator异常加入《全局异常处理器》
 
  
##一、课程目标
1. 什么是Validator参数校验器？ 为什么要用？
2. 编码实现对用户名、密码、邮箱、身份证的Validator校验
3. 实现一个手机号码的自定义校验
4. 把validator异常加入《全局异常处理器》

##二、 为什么要用Validator参数校验器，它解决了什么问题？
背景：在日常的接口开发中，经常要对接口的参数做校验，例如，登录的时候要校验用户名 密码是否为空。但是这种日常的接口参数校验太烦锁了，代码繁琐又多。

Validator框架就是为了解决开发人员在开发的时候少写代码，提升开发效率的；它专门用来做接口参数的校验的，例如 email校验、用户名长度必须位于6到12之间 等等。

原理：spring 的validator校验框架遵循了JSR-303验证规范（参数校验规范）,JSR是Java Specification Requests的缩写。

在默认情况下，Spring Boot会引入Hibernate Validator机制来支持JSR-303验证规范。

spring boot的validator校验框架有3个特性：
1. JSR303特性： JSR303是一项标准,只提供规范不提供实现，规定一些校验规范即校验注解，如@Null，@NotNull，@Pattern，位于javax.validation.constraints包下。
2. hibernate validation特性：hibernate validation是对JSR303规范的实现，并增加了一些其他校验注解，如@Email，@Length，@Range等等
3. spring validation：spring validation对hibernate validation进行了二次封装，在springmvc模块中添加了自动校验，并将校验信息封装进了特定的类中。

##三、案例实战：实现一个SpringBoot的参数校验功能
### 步骤1：pom文件加入依赖包
springboot天然支持validator数据校验
``` 

    org.springframework.boot
    spring-boot-starter-web

```

### 步骤2：创建一个VO类
``` 

@Data
public class UserVO {

    private Integer id;

    @NotEmpty(message="用户名不能为空")
    @Length(min=6,max = 12,message="用户名长度必须位于6到12之间")
    private String username;

    @NotEmpty(message="密码不能为空")
    @Length(min=6,message="密码长度不能小于6位")
    private String password;

    @Email(message="请输入正确的邮箱")
    private String email;

//    @Phone
//    private String phone;

    @Pattern(regexp = "^(\\d{18,18}|\\d{15,15}|(\\d{17,17}[x|X]))$", message = "身份证格式错误")
    private String idCard;

    private Byte sex;
    private Byte deleted;
    private Date updateTime;
    private Date createTime;
}
```

### 步骤3：加一个体验类
``` 
@Api(description = "用户接口")
@RestController
@RequestMapping("/user")
public class UserController {

    @PostMapping(value = "/user/create", produces = APPLICATION_JSON_UTF8_VALUE, consumes = APPLICATION_JSON_UTF8_VALUE)
    public void crreteUser(@RequestBody @Validated UserVO userVO) {

    }

}
```
注意：以上代码一定要加上@Validated注解，它的作用是用来校验UserVO的参数是否正确

执行结果：

``` 
{
  "timestamp": "2019-10-03T02:34:54.545+0000",
  "status": 400,
  "error": "Bad Request",
  "errors": [
    {
      "codes": [
        "Pattern.userVO.idCard",
        "Pattern.idCard",
        "Pattern.java.lang.String",
        "Pattern"
      ],
      "arguments": [
        {
          "codes": [
            "userVO.idCard",
            "idCard"
          ],
          "arguments": null,
          "defaultMessage": "idCard",
          "code": "idCard"
        },
        [],
        {
          "defaultMessage": "^(\\d{18,18}|\\d{15,15}|(\\d{17,17}[x|X]))$",
          "arguments": null,
          "codes": [
            "^(\\d{18,18}|\\d{15,15}|(\\d{17,17}[x|X]))$"
          ]
        }
      ],
      "defaultMessage": "身份证格式错误",
      "objectName": "userVO",
      "field": "idCard",
      "rejectedValue": "string",
      "bindingFailure": false,
      "code": "Pattern"
    },
    {
      "codes": [
        "Email.userVO.email",
        "Email.email",
        "Email.java.lang.String",
        "Email"
      ],
      "arguments": [
        {
          "codes": [
            "userVO.email",
            "email"
          ],
          "arguments": null,
          "defaultMessage": "email",
          "code": "email"
        },
        [],
        {
          "defaultMessage": ".*",
          "arguments": null,
          "codes": [
            ".*"
          ]
        }
      ],
      "defaultMessage": "请输入正确的邮箱",
      "objectName": "userVO",
      "field": "email",
      "rejectedValue": "string",
      "bindingFailure": false,
      "code": "Email"
    }
  ],
  "message": "Validation failed for object='userVO'. Error count: 2",
  "path": "/user/user/create"
}
```


## 四、Validation常用注解

- @Null 限制只能为null
- @NotNull 限制必须不为null
- @AssertFalse 限制必须为false
- @AssertTrue 限制必须为true
- @DecimalMax(value) 限制必须为一个不大于指定值的数字
- @DecimalMin(value) 限制必须为一个不小于指定值的数字
- @Digits(integer,fraction) 限制必须为一个小数，且整数部分的位数不能超过integer，小数部分的位数不能超过fraction
- @Future 限制必须是一个将来的日期
- @Max(value) 限制必须为一个不大于指定值的数字
- @Min(value) 限制必须为一个不小于指定值的数字
- @Past 限制必须是一个过去的日期
- @Pattern(value) 限制必须符合指定的正则表达式
- @Size(max,min) 限制字符长度必须在min到max之间
- @Past 验证注解的元素值（日期类型）比当前时间早
- @NotEmpty 验证注解的元素值不为null且不为空（字符串长度不为0、集合大小不为0）
- @NotBlank 验证注解的元素值不为空（不为null、去除首位空格后长度为0），不同于@NotEmpty，@NotBlank只应用于字符串且在比较时会去除字符串的空格
- @Email 验证注解的元素值是Email，也可以通过正则表达式和flag指定自定义的email格式


##自定义validator注解
为什么要自定义validator注解呢？
因为validator框架支持的注解有限，不可能方方面面都支持，故需要我们自定义注解。
我们就以手机号码为例子，教大家如何写一个对手机号码校验的validator注解。
### 步骤1：创建一个@interface的手机校验注解
``` 
@Documented
// 指定注解的实现类
@Constraint(validatedBy = PhoneValidator.class)
@Target( { METHOD, FIELD })
@Retention(RUNTIME)
public @interface Phone {
    String message() default "请输入正确的手机号码";

    Class[] groups() default { };

    Class[] payload() default { };

    @Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
    @Retention(RUNTIME)
    @Documented
    @interface List {
        Phone[] value();
    }
}

```

### 步骤2：手机号码校验注解实现类
``` 

public class PhoneValidator implements ConstraintValidator {

    private static final Pattern PHONE_PATTERN = Pattern.compile(
            "^((13[0-9])|(15[^4])|(18[0,2,3,5-9])|(17[0-8])|(147))\\d{8}$"
    );

    @Override
    public void initialize(Phone constraintAnnotation) {

    }

    /**
     *
     * 校验的实现逻辑
     */
    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        if ( value == null || value.length() == 0 ) {
            return true;
        }
        Matcher m = PHONE_PATTERN.matcher(value);
        return m.matches();
    }
}
```

### 步骤3：给UserVO类，加上手机号码校验注解
``` 

@Data
public class UserVO {

    private Integer id;

    @NotEmpty(message="用户名不能为空")
    @Length(min=6,max = 12,message="用户名长度必须位于6到12之间")
    private String username;

    @NotEmpty(message="密码不能为空")
    @Length(min=6,message="密码长度不能小于6位")
    private String password;

    @Email(message="请输入正确的邮箱")
    private String email;

    @Phone
    private String phone;

    @Pattern(regexp = "^(\\d{18,18}|\\d{15,15}|(\\d{17,17}[x|X]))$", message = "身份证格式错误")
    private String idCard;

    private Byte sex;
    private Byte deleted;
    private Date updateTime;
    private Date createTime;
}
```
### 步骤4：体验效果
``` 
{
  "timestamp": "2019-10-03T03:42:10.928+0000",
  "status": 400,
  "error": "Bad Request",
  "errors": [
    {
      "codes": [
        "Phone.userVO.phone",
        "Phone.phone",
        "Phone.java.lang.String",
        "Phone"
      ],
      "arguments": [
        {
          "codes": [
            "userVO.phone",
            "phone"
          ],
          "arguments": null,
          "defaultMessage": "phone",
          "code": "phone"
        }
      ],
      "defaultMessage": "请输入正确的手机号码",
      "objectName": "userVO",
      "field": "phone",
      "rejectedValue": "string",
      "bindingFailure": false,
      "code": "Phone"
    }
  ],
  "message": "Validation failed for object='userVO'. Error count: 1",
  "path": "/user/user/create"
}
```


## 六、把validator异常加入《全局异常处理器》
那为什么要把validator异常加入《全局异常处理器》呢？
因为validator异常返回的内容是json，而且json数据结构（例如上文的json）特别复杂.
不利于客户端联调，而且也不友好提示，故，必须加入《全局异常处理器》

### 步骤1：《全局异常处理器》加入validator异常处理

``` 
    /**
     * validator 统一异常封装
     */
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ErrorResult handleMethodArgumentNotValidException(MethodArgumentNotValidException e, HttpServletRequest request) {
        String msgs = this.handle(e.getBindingResult().getFieldErrors());
        ErrorResult error = ErrorResult.fail(ResultCode.PARAM_IS_INVALID, e,  msgs);
        log.warn("URL:{} ,参数校验异常:{}", request.getRequestURI(),msgs);
        return error;
    }

    private String handle(List fieldErrors) {
        StringBuilder sb = new StringBuilder();
        for (FieldError obj : fieldErrors) {
            sb.append(obj.getField());
            sb.append("=[");
            sb.append(obj.getDefaultMessage());
            sb.append("]  ");
        }
		return sb.toString();
    }
```
### 步骤2：结果
``` 
{
  "status": 10001,
  "desc": "idCard=[身份证格式错误]  email=[请输入正确的邮箱]  phone=[请输入正确的手机号码]  ",
  "data": null
}
```
### 七：课后练习题
本课程的UserVO,还遗留了一个sex没有校验，请为该字段设计一个自定义注解；
注解的校验规则：0=女，1=男，输入错误提示：性别输入错误！

 
  
为什么要把validator异常加入《全局异常处理器》呢？
 
  
因为validator异常返回的内容是json，而且json数据结构（例如上文的json）特别复杂.
 不利于客户端联调，而且也不友好提示，故，必须加入《全局异常处理器》
 
  
接口攻击：sign+timestamp
 
  
springboot安全:接口攻击

### 本课程目标：
面试的时候经常会被问到，如何保证你的接口完全？接口安全最常见的做法就是篡改和重放。

故，本节课我们就来学习：
1. 什么是接口篡改攻击？
2. 什么是重放攻击？
3. 编码实现SpringBoot的签名保护，防篡改重放攻击

### 一、为什么API接口是不安全的？
对于互联网来说，只要你系统的接口暴露在外网，就避免不了接口安全问题。
如果你的接口在外网裸奔，只要让黑客知道接口的地址和参数就可以调用，那简直就是灾难。

举个例子：你的网站用户注册的时候，需要填写手机号，发送手机验证码，如果这个发送验证码的接口没有经过特殊安全处理，那这个短信接口早就被人盗刷不知道浪费了多少钱了。

### 二、看看淘宝的API接口安全是怎么做的？
浏览器输入：https://h5.m.taobao.com/
然后过滤带有sign的URL

![image](https://github.com/agan-java/images/blob/master/sign/01.png?raw=true)

![image](https://github.com/agan-java/images/blob/master/sign/02.png?raw=true)

从上图可以看出，淘宝的接口统一加了t 和 sign 来实现接口安全的，先别急，接下来我们会一一讲解这2个参数的原理。

### 三、什么是接口篡改攻击？
接口篡改是指黑客通过http捉包的形式获取了你api接口的请求参数，然后篡改api参数内容，重新发送api请求。
例如上文说的，黑客通过http捉包破解了你的手机发送验证码接口，然后篡改手机号码，最终盗刷短信，浪费你的钱财。

### 四、接口如何实现请求内容防止篡改？
一般的做法有2种：
1. 采用https方式把接口的数据进行加密传输，即便是被黑客破解，黑客也花费大量的时间和精力去破解。
2. 接口后台对接口的请求参数进行验证，防止被黑客篡改；原理如下：

![image](https://github.com/agan-java/images/blob/master/sign/03.png?raw=true)

- 步骤1：服务端和客户端约定好加密规则，然后彼此都对api接口参数进行加密。
- 步骤2：客户端按步骤1，对api传输参数进行加密后得到签名值sign1,并将sign1,发送给服务端。
- 步骤3：服务端接收到客户端的请求后，按步骤1对请求参数进行加密，得到签名值sign2.
- 步骤4：服务端比对sign1和sign2的值，如果不一致，就认定为被篡改，非法请求。

以上2种方式，互联网公司都是同时采用的，例如淘宝。

### 五、什么是重放攻击？
重放攻击说白了就是黑客通过http捉包的形式，获取了你接口的请求参数（没篡改内容），然后重复发送请求。
重复攻击会造成2种严重后果：
1. 针对插入数据库接口：重放攻击，会出现大量重复数据，甚至垃圾数据会把数据库撑爆。
2. 针对查询的接口：黑客一般是重点攻击慢查询接口，例如一个慢查询接口1s，只要黑客发起重放攻击，就必然造成系统被拖垮，数据库查询被阻塞死。

### 六、接口如何实现请求内容防止重放？
业界的做法通常是基于timestamp的方案(淘宝也是这种方案)来防止重放。
原理如下：
![image](https://github.com/agan-java/images/blob/master/sign/04.png?raw=true)

- 步骤1：客户端每次发起http请求，而外新增timestamp参数，一起发生给服务端。
- 步骤2：服务端接收到http请求后，判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。

也许有的同学会问，黑客每次请求完后再修改timestamp时间戳，不就破解你这个防止重放算法了吗

![image](https://github.com/agan-java/images/blob/master/sign/05.png?raw=true)

这确实，能被破解，那如何防止呢？ 大家想一想，黑客修改我们的timestamp，是不是就是上文说的接口篡改，
所以采用上文的知识点，把timestamp和api参数一起进行加密后得到签名值sign1,并将sign1,发送给服务端；服务端再做验证就解决问题了。

 
  
防篡改、防重放攻击过滤器
 
  
/**
 * 防篡改、防重放攻击过滤器
 */
@Slf4j
public class SignFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) {
        log.info("初始化 signfilter.............");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filter) throws ServletException, IOException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;
        log.debug("过滤URL:{}", httpRequest.getRequestURI());

        HttpServletRequestWrapper requestWrapper = new HttpServletRequestWrapper(httpRequest);
        String sign = httpRequest.getHeader("sign");
        //验证sign不能为空
        if (StringUtils.isEmpty(sign)) {
            responseFail(httpResponse);
            return;
        }
        //验证timestamp是否为空
        String time = httpRequest.getHeader("timestamp");
        if (StringUtils.isEmpty(time)) {
            responseFail(httpResponse);
            return;
        }
        /*
         * 重放处理
         * 判断timestamp时间戳与当前时间是否操过60s（过期时间根据业务情况设置）,如果超过了就提示签名过期。
         */
        long timestamp = Long.valueOf(time);
        long now = System.currentTimeMillis() / 1000;
        //为了方便测试这里改成1小时
        long n = 60 * 60;
        if (now - timestamp > n) {
            responseFail(httpResponse);
            return;
        }

        boolean accept = true;
        SortedMap paramMap;
        switch (httpRequest.getMethod()) {
            case "GET":
                paramMap = HttpDataUtil.getUrlParams(requestWrapper);
                accept = SignUtil.verifySign(paramMap, sign, timestamp);
                break;
            case "POST":
            case "PUT":
            case "DELETE":
                paramMap = HttpDataUtil.getBodyParams(requestWrapper);
                accept = SignUtil.verifySign(paramMap, sign, timestamp);
                break;
            default:
                accept = true;
                break;
        }

        if (accept) {
            filter.doFilter(requestWrapper, response);
        } else {
            responseFail(httpResponse);
            return;
        }

    }

    /**
     * 异常返回
     */
    private void responseFail(HttpServletResponse response) throws IOException {
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        //抛出异常401 未授权状态码
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        PrintWriter out = response.getWriter();
        //统一提示：签名验证失败
        Result fail = Result.fail(ResultCode.UNAUTHORIZED);
        String result = JsonUtil.object2Json(fail);
        out.println(result);
        out.flush();
        out.close();
    }

}
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(spring)

        

            

                
    
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                    
  • RabbitMQ生产者重复机制与确认机制
                        java炒饭小能手
java-rabbitmqrabbitmqjava
                        
    重复机制生产者发送消息时，出现了网络故障，导致与MQ的连接中断。为了解决这个问题，SpringAMQP提供的消息发送时的重试机制。即：当RabbitTemplate与MQ连接超时后，多次重试。需要修该发送端模块的application.yaml文件，添加下面的内容：spring:rabbitmq:connection-timeout:1s#设置MQ的连接超时时间template:retry:ena
    
                    
    • 
                    
  • 【Java】已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException
                        屿小夏
java开发语言
                        
    文章目录一、分析问题背景问题背景描述出现问题的场景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：org.springframework.jdbc.datasource.lookup.DataSourceLookupFailureException在使用Spring框架进行开发时，数据源的配置和使用是非常关键的一环。然而，有时候我们可能会遇到org.springframewo
    
                    
    • 
                    
  • SpringBoot和SpringMVC是什么关系?SpringBoot替代SpringMVC了吗?
                        瑞金彭于晏
springboot后端javaMVCspring数据库
                        
    SpringBoot和SpringMVC都是SpringFramework生态系统中的一部分，但它们各自扮演着不同的角色和提供不同的功能集。理解它们之间的关系，首先需要了解SpringFramework本身。SpringFrameworkSpringFramework是一个全面的、开源的应用程序开发框架，它提供了广泛的功能来支持企业应用开发的几乎所有方面。SpringFramework的核心特性之
    
                    
    • 
                    
  • spring mvc @RequestBody String类型参数
                        zoyation
spring-mvcspringmvc
                        
    通过如下配置：text/html;charset=UTF-8application/json;charset=UTF-8在springmvc的Controller层使用@RequestBody接收Content-Type为application/json的数据时，默认支持Map方式和对象方式参数@RequestMapping(value="/{code}/saveUser",method=Requ
    
                    
    • 
                    
  • Java -jar 如何在后台运行项目
                        vincent_hahaha

                        
    撸了今年阿里、头条和美团的面试，我有一个重要发现.......>>>说到运行jar包通常我们都会以下面的方式运行:java-jarspringboot-0.0.1-SNAPSHOT.jar这样运行的话会有一个问题，就是我们一关闭当前窗口就会停止运行项目，要想解决这个问题，就需要在后台运行。nohupjava-jarbabyshark-0.0.1-SNAPSHOT.jar >log.file 2>&
    
                    
    • 
                    
  • spring security中几大组件的作用和执行顺序
                        阿信在这里
javaspring
                        
    springsecurity中几大组件的作用和执行顺序在SpringSecurity中，AuthenticationProvider、GroupPermissionEvaluator、PermissionEvaluator、AbstractAuthenticationProcessingFilter、DefaultMethodSecurityExpressionHandler和ManageSecu
    
                    
    • 
                    
  • 探索Zebra4J：构建高效企业级Web应用的微服务框架
                        叶准鑫Natalie

                        
    探索Zebra4J：构建高效企业级Web应用的微服务框架ZebraZebra4J/Zebra4Js基于SpringBoot的JavaWeb/Nodejs框架项目地址:https://gitcode.com/gh_mirrors/zebra/Zebra项目介绍在当今快速发展的技术环境中，构建高效、可扩展的企业级Web应用是每个开发团队的追求。Zebra4J作为一款基于SpringBoot的全新微服务
    
                    
    • 
                    
  • 基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台
                        网顺技术团队
成品程序项目javavue.js汽车课程设计springboot
                        
    基于JavaWeb开发的Java+SpringMvc+vue+element实现上海汽车博物馆平台作者主页网顺技术团队欢迎点赞收藏⭐留言文末获取源码联系方式查看下方微信号获取联系方式承接各种定制系统精彩系列推荐精彩专栏推荐订阅不然下次找不到哟Java毕设项目精品实战案例《1000套》感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人文章目录基
    
                    
    • 
                    
  • 分布式锁和spring事务管理
                        暴躁的鱼
锁及事务分布式springjava
                        
    最近开发一个小程序遇到一个需求需要实现分布式事务管理业务需求用户在使用小程序的过程中可以查看景点，对景点地区或者城市标记是否想去，那么需要统计一个地点被标记的人数，以及记录某个用户对某个地点是否标记为想去，用两个表存储数据，一个地点表记录改地点被标记的次数，一个用户意向表记录某个用户对某个地点是否标记为想去。由于可能有多个用户同时标记一个地点，每个用户在前端点击想去按钮之后，后台接收到请求，从数据
    
                    
    • 
                    
  • Java面试笔记记录6
                        今天背八股了吗
java面试笔记
                        
    1.Spring是什么？特性？有哪些模块？Spring是一个轻量级、非入侵式的控制反转Ioc和面向切面AOP的框架。特性：1.Ioc和DISpring的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring工厂用于生成Bean，并且管理Bean的生命周期，实现高内聚低耦合的设计理念。2.AOP编程Spring提供面向切面编程，可以方便实现对程序进行权限拦截、运行监控等切面功能。3
    
                    
    • 
                    
  • Sentinel
                        眼泪落在琴弦
springcloudjavajava
                        
    Sentinel（服务熔断降级限流）1.引入spring-cloud-starter-alibaba-sentinel2.下载sentinel服务器3.配置application地址信息4.在控制台调整参数【默认所以流控设置保存在内存中，重启失效】5.想实时监控需每个微服务导入actuator，并配置application暴露所有端口6.自定义sentinel流控返回数据7.配置sentinel类
    
                    
    • 
                    
  • Spring @Async 深度解读：默认线程池执行器的配置与优化
                        小码快撩
springjava前端
                        
    在Spring中，@Async注解用于异步执行方法。默认情况下，@Async注解的任务是由一个线程池执行的。然而，这个默认的线程池是如何初始化的呢？本文将深入探讨这一过程，帮助你理解Spring异步任务背后的线程池执行器的初始化原理。1.@Async的基本使用首先，让我们快速回顾一下@Async的基本用法。@Async通常用于标注在需要异步执行的方法上，比如：@Servicepublicclass
    
                    
    • 
                    
  • Sentinel实时监控不展示问题
                        朱杰jjj
sentinelsentinel
                        
    问题官方插件Endpoint支持，可以实时统计出SpringBoot的健康状况和请求的调用信息在使用Endpoint特性之前需要在Maven中添加spring-boot-starter-actuator依赖，并在配置中允许Endpoints的访问。SpringBoot1.x中添加配置management.security.enabled=false。暴露的endpoint路径为/sentinelS
    
                    
    • 
                    
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？
                        这孩子叫逆
Mybatis笔记mybatis数据库
                        
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • Spring Security静态资源过滤（11）
                        小黑屋说YYDS
spring
                        
    在一个实际项目中，并非所有的请求都需要经过SpringSecurity过滤器，有一些特殊的请求，例如静态资源等，一般来说并不需要经过SpringSecurity过滤器链，用户如果访问这些静态资源，直接返回对应的资源即可。回顾关于WebSecurity的讲解，提到它里边维护了一个ignoredRequests变量,该变量，记录的就是所有需要被忽略的请求，这些被忽略的请求将不再经过SpringSecu
    
                    
    • 
                    
  • Spring Security定义多个过滤器链（10）
                        小黑屋说YYDS
spring
                        
    在SpringSecurity中可以同时存在多个过滤器链，一个WebSecurityConfigurerAdapter的实例就可以配置一条过滤器链。我们来看如下一个案例：@ConfigurationpublicclassSecurityConfig{@BeanUserDetailsServiceus(){InMemoryUserDetailsManagerusers=newInMemoryUser
    
                    
    • 
                    
  • java 技术 架构 相关文档
                        圣心
java架构开发语言
                        
    在Java中，有许多不同的技术和架构，这里我将列举一些常见的Java技术和架构，并提供一些相关的文档资源。SpringFrameworkSpring是一个开源的Java/JavaEE全功能框架，以Apache许可证形式发布，提供了一种实现企业级应用的方法。官方文档：SpringFrameworkSpringBootSpringBoot是Spring的一个子项目，旨在简化创建生产级的Spring应用
    
                    
    • 
                    
  • SpringSecurity初学总结
                        weixin_66442229
spring
                        
    springSecurity安全框架基于Java的安全框架主要有:SpringSecurity和Shiro介绍基础概念安全框架是对用户访问权限的控制,保证应用的安全性。其主要的工作是用户认证和用户授权|鉴权主要应用于Spring的企业应用系统,提供声明式的安全访问控制解决方案。它提供了一组可以在Spring应用上下文中配置的Bean能很好的结合Spring的DI依赖注入和AOP面向切面编程功能应用
    
                    
    • 
                    
  • java获取applicationcontext,SpringBoot获取ApplicationContext的3种方式
                        花儿街参考

                        
    ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能。ApplicationContext获取的几种方式1直接使用Autowired注入@ComponentpublicclassBook1{@AutowiredprivateApplicationContextapplicationContext;pub
    
                    
    • 
                    
  • SpringBoot 设置传入参数非必要
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    查看RequestParam源码packageorg.springframework.web.bind.annotation;importjava.lang.annotation.Documented;importjava.lang.annotation.ElementType;importjava.lang.annotation.Retention;importjava.lang.annotat
    
                    
    • 
                    
  • SpringBoot 获取 ApplicationContext
                        loveLifeLoveCoding
springbootspringbootjavaspring
                        
    1.概念ApplicationContext是什么？简单来说就是Spring中的容器，可以用来获取容器中的各种bean组件，注册监听事件，加载资源文件等功能2.获取ApplicationContext的方式2.1.创建工具类通过此工具类，可以方便的获取bean组件,获取配置信息等importorg.springframework.beans.BeansException;importorg.spr
    
                    
    • 
                    
  • java打印标签（机型TOSHIBA条码打印机B-EX4T）
                         嘘 
JAVAjava
                        
    java打印标签实现方式标签效果代码获取更多相关资料实现rfid写入功能实现方式打印机设置网络ipjava获取socket连接，调用TPCL指令标签效果代码packageorg.jeecg.modules.invinfo.util;importorg.jeecg.modules.invinfo.vo.BatKcInventoryDetailVo;importorg.springframework.
    
                    
    • 
                                
  • Linux的Initrd机制
                                    被触发
linux
                                    
    Linux 的 initrd 技术是一个非常普遍使用的机制，linux2.6 内核的 initrd 的文件格式由原来的文件系统镜像文件转变成了 cpio 格式，变化不仅反映在文件格式上， linux 内核对这两种格式的 initrd 的处理有着截然的不同。本文首先介绍了什么是 initrd 技术，然后分别介绍了 Linux2.4 内核和 2.6 内核的 initrd 的处理流程。最后通过对 Lin
    
                                
    • 
                                
  • maven本地仓库路径修改
                                    bitcarter
maven
                                    
    默认maven本地仓库路径：C:\Users\Administrator\.m2 
 
修改maven本地仓库路径方法： 
    
1.打开E:\maven\apache-maven-2.2.1\conf\settings.xml 
    
2.找到 
       
    
                                
    • 
                                
  • XSD和XML中的命名空间
                                    darrenzhu
xmlxsdschemanamespace命名空间
                                    
    http://www.360doc.com/content/12/0418/10/9437165_204585479.shtml 

http://blog.csdn.net/wanghuan203/article/details/9203621 

http://blog.csdn.net/wanghuan203/article/details/9204337 
 

http://www.cn
    
                                
    • 
                                
  • Java 求素数运算
                                    周凡杨
java算法素数
                                    
    网络上对求素数之解数不胜数，我在此总结归纳一下，同时对一些编码，加以改进，效率有成倍热提高。   
第一种：    
  
原理: 6N(+-)1法              任何一个自然数，总可以表示成为如下的形式之一： 6N，6N+1，6N+2，6N+3，6N+4，6N+5 (N=0，1，2，…)    
    
                                
    • 
                                
  • java 单例模式
                                    g21121
java
                                    
    想必单例模式大家都不会陌生，有如下两种方式来实现单例模式： 
  
class Singleton {
  private static Singleton instance=new Singleton();
  private Singleton(){}
  static Singleton getInstance() {
      return instance;
  }
    
                                
    • 
                                
  • Linux下Mysql源码安装
                                    510888780
mysql
                                    
    1.假设已经有mysql-5.6.23-linux-glibc2.5-x86_64.tar.gz 
 
(1)创建mysql的安装目录及数据库存放目录       
解压缩下载的源码包，目录结构，特殊指定的目录除外： 
          
    
                                
    • 
                                
  • 32位和64位操作系统
                                    墙头上一根草
32位和64位操作系统
                                    
    32位和64位操作系统是指：CPU一次处理数据的能力是32位还是64位。现在市场上的CPU一般都是64位的，但是这些CPU并不是真正意义上的64 位CPU，里面依然保留了大部分32位的技术，只是进行了部分64位的改进。32位和64位的区别还涉及了内存的寻址方面，32位系统的最大寻址空间是2 的32次方= 4294967296（bit）= 4（GB）左右，而64位系统的最大寻址空间的寻址空间则达到了
    
                                
    • 
                                
  • 我的spring学习笔记10-轻量级_Spring框架
                                    aijuans
Spring 3
                                    
    一、问题提问： 
 
    → 请简单介绍一下什么是轻量级？ 
 
    轻量级（Leightweight）是相对于一些重量级的容器来说的，比如Spring的核心是一个轻量级的容器，Spring的核心包在文件容量上只有不到1M大小，使用Spring核心包所需要的资源也是很少的，您甚至可以在小型设备中使用Spring。 
 
 
    
                                
    • 
                                
  • mongodb 环境搭建及简单CURD
                                    antlove
WebInstallcurdNoSQLmongo
                                    
    一 搭建mongodb环境 
1. 在mongo官网下载mongodb 
2. 在本地创建目录 "D:\Program Files\mongodb-win32-i386-2.6.4\data\db" 
3. 运行mongodb服务 [mongod.exe --dbpath "D:\Program Files\mongodb-win32-i386-2.6.4\data\
    
                                
    • 
                                
  • 数据字典和动态视图
                                    百合不是茶
oracle数据字典动态视图系统和对象权限
                                    
    数据字典（data dictionary）是 Oracle 数据库的一个重要组成部分，这是一组用于记录数据库信息的只读（read-only）表。随着数据库的启动而启动,数据库关闭时数据字典也关闭   数据字典中包含 
  
 
 数据库中所有方案对象（schema object）的定义(包括表，视图，索引，簇，同义词，序列，过程，函数，包，触发器等等) 
 数据库为一
    
                                
    • 
                                
  • 多线程编程一般规则
                                    bijian1013
javathread多线程java多线程
                                    
           如果两个工两个以上的线程都修改一个对象，那么把执行修改的方法定义为被同步的，如果对象更新影响到只读方法，那么只读方法也要定义成同步的。 
       不要滥用同步。如果在一个对象内的不同的方法访问的不是同一个数据，就不要将方法设置为synchronized的。 

    
                                
    • 
                                
  • 将文件或目录拷贝到另一个Linux系统的命令scp
                                    bijian1013
linuxunixscp
                                    
    一.功能说明        scp就是security copy，用于将文件或者目录从一个Linux系统拷贝到另一个Linux系统下。scp传输数据用的是SSH协议，保证了数据传输的安全，其格式如下：        scp 远程用户名@IP地址：文件的绝对路径
    
                                
    • 
                                
  • 【持久化框架MyBatis3五】MyBatis3一对多关联查询
                                    bit1129
Mybatis3
                                    
    以教员和课程为例介绍一对多关联关系，在这里认为一个教员可以叫多门课程，而一门课程只有1个教员教，这种关系在实际中不太常见，通过教员和课程是多对多的关系。 
  示例数据：
  
  
地址表： 
  
CREATE TABLE ADDRESSES 
(
  ADDR_ID INT(11) NOT NULL AUTO_INCREMENT,
  STREET VAR
    
                                
    • 
                                
  • cookie状态判断引发的查找问题
                                    bitcarter
formcgi
                                    
    先说一下我们的业务背景： 
1.前台将图片和文本通过form表单提交到后台，图片我们都做了base64的编码，并且前台图片进行了压缩 
2.form中action是一个cgi服务 
3.后台cgi服务同时供PC，H5，APP 
4.后台cgi中调用公共的cookie状态判断方法（公共的，大家都用，几年了没有问题） 
 
问题：（折腾两天。。。。） 
1.PC端cgi服务正常调用，cookie判断没
    
                                
    • 
                                
  • 通过Nginx,Tomcat访问日志(access log)记录请求耗时
                                    ronin47

                                    
    一、Nginx通过$upstream_response_time $request_time统计请求和后台服务响应时间 
nginx.conf使用配置方式： 
log_format main '$remote_addr - $remote_user [$time_local] "$request" ''$status $body_bytes_sent "$http_r
    
                                
    • 
                                
  • java-67- n个骰子的点数。 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。
                                    bylijinnan
java
                                    
    

public class ProbabilityOfDice {

	/**
	 * Q67 n个骰子的点数
	 * 把n个骰子扔在地上，所有骰子朝上一面的点数之和为S。输入n，打印出S的所有可能的值出现的概率。
	 * 在以下求解过程中，我们把骰子看作是有序的。
	 * 例如当n=2时，我们认为（1，2）和（2，1）是两种不同的情况
	 */
	private stati
    
                                
    • 
                                
  • 看别人的博客，觉得心情很好
                                    Cb123456
博客心情
                                    
       以为写博客，就是总结，就和日记一样吧，同时也在督促自己。今天看了好长时间博客: 
   职业规划: 
   http://www.iteye.com/blogs/subjects/zhiyeguihua 
  
   android学习: 
   1.http://byandby.i
    
                                
    • 
                                
  • [JWFD开源工作流]尝试用原生代码引擎实现循环反馈拓扑分析
                                    comsci
工作流
                                    
     
    我们已经不满足于仅仅跳跃一次，通过对引擎的升级，今天我测试了一下循环反馈模式，大概跑了200圈，引擎报一个溢出错误 
 
     在一个流程图的结束节点中嵌入一段方程，每次引擎运行到这个节点的时候，通过实时编译器GM模块，计算这个方程，计算结果与预设值进行比较，符合条件则跳跃到开始节点，继续新一轮拓扑分析，直到遇到
    
                                
    • 
                                
  • JS常用的事件及方法
                                    cwqcwqmax9
js
                                    
    事件 描述 
onactivate 当对象设置为活动元素时触发。 
onafterupdate 当成功更新数据源对象中的关联对象后在数据绑定对象上触发。 
onbeforeactivate 对象要被设置为当前元素前立即触发。 
onbeforecut 当选中区从文档中删除之前在源对象触发。 
onbeforedeactivate 在 activeElement 从当前对象变为父文档其它对象之前立即
    
                                
    • 
                                
  • 正则表达式验证日期格式
                                    dashuaifu
正则表达式IT其它java其它
                                    
                     正则表达式验证日期格式

function isDate(d){
 var v = d.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/i);
 if(!v) {
  this.focus();
  return false;
 }
}
<input value="2000-8-8" onblu
    
                                
    • 
                                
  • Yii CModel.rules() 方法 、validate预定义完整列表、以及说说验证
                                    dcj3sjt126com
yii
                                    
    public array rules () {return} array 要调用 validate() 时应用的有效性规则。 返回属性的有效性规则。声明验证规则，应重写此方法。 每个规则是数组具有以下结构：array('attribute list', 'validator name', 'on'=>'scenario name', ...validation 
    
                                
    • 
                                
  • UITextAttributeTextColor = deprecated in iOS 7.0
                                    dcj3sjt126com
ios
                                    
    In this lesson we used the key "UITextAttributeTextColor" to change the color of the UINavigationBar appearance to white. This prompts a warning "first deprecated in iOS 7.0." 
Ins
    
                                
    • 
                                
  • 判断一个数是质数的几种方法
                                    EmmaZhao
Mathpython
                                    
    质数也叫素数，是只能被1和它本身整除的正整数，最小的质数是2，目前发现的最大的质数是p=2^57885161-1【注1】。 
判断一个数是质数的最简单的方法如下： 
 

def isPrime1(n):
	for i in range(2, n):
		if n % i == 0:
			return False
	return True
 
但是在上面的方法中有一些冗余的计算，所以
    
                                
    • 
                                
  • SpringSecurity工作原理小解读
                                    坏我一锅粥
SpringSecurity
                                    
     
   SecurityContextPersistenceFilter 
   ConcurrentSessionFilter 
   WebAsyncManagerIntegrationFilter 
   HeaderWriterFilter 
   CsrfFilter 
   LogoutFilter 
   Use
    
                                
    • 
                                
  • JS实现自适应宽度的Tag切换
                                    ini
JavaScripthtmlWebcsshtml5
                                    
    效果体验：http://hovertree.com/texiao/js/3.htm 
  
该效果使用纯JavaScript代码，实现TAB页切换效果，TAB标签根据内容自适应宽度，点击TAB标签切换内容页。 
HTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
    
                                
    • 
                                
  • Hbase Rest API : 数据查询
                                    kane_xie
RESThbase
                                    
    hbase（hadoop）是用java编写的，有些语言（例如python）能够对它提供良好的支持，但也有很多语言使用起来并不是那么方便，比如c#只能通过thrift访问。Rest就能很好的解决这个问题。Hbase的org.apache.hadoop.hbase.rest包提供了rest接口，它内嵌了jetty作为servlet容器。 
  
启动命令：./bin/hbase rest s
    
                                
    • 
                                
  • JQuery实现鼠标拖动元素移动位置（源码+注释）
                                    明子健
jqueryjs源码拖动鼠标
                                    
    欢迎讨论指正！ 
  
print.html代码： 
<!DOCTYPE html>
<html>
<head>
<meta http-equiv=Content-Type content="text/html;charset=utf-8">
<title>发票打印</title>
&l
    
                                
    • 
                                
  • Postgresql 连表更新字段语法 update
                                    qifeifei
PostgreSQL
                                    
    下面这段sql本来目的是想更新条件下的数据，可是这段sql却更新了整个表的数据。sql如下： 
UPDATE tops_visa.visa_order
SET op_audit_abort_pass_date = now()
FROM
	tops_visa.visa_order as  t1
INNER JOIN tops_visa.visa_visitor as t2 
ON t1. 
    
                                
    • 
                                
  • 将redis,memcache结合使用的方案?
                                    tcrct
rediscache
                                    
    公司架构上使用了阿里云的服务，由于阿里的kvstore收费相当高，打算自建，自建后就需要自己维护，所以就有了一个想法，针对kvstore(redis)及ocs(memcache)的特点，想自己开发一个cache层，将需要用到list，set，map等redis方法的继续使用redis来完成，将整条记录放在memcache下，即findbyid，save等时就memcache，其它就对应使用redi
    
                                
    • 
                                
  • 开发中遇到的诡异的bug
                                    wudixiaotie
bug
                                    
    今天我们服务器组遇到个问题： 
我们的服务是从Kafka里面取出数据，然后把offset存储到ssdb中，每个topic和partition都对应ssdb中不同的key，服务启动之后，每次kafka数据更新我们这边收到消息，然后存储之后就发现ssdb的值偶尔是-2,这就奇怪了，最开始我们是在代码中打印存储的日志，发现没什么问题，后来去查看ssdb的日志，才发现里面每次set的时候都会对同一个key
    
                                
    •