diff --git a/springboot系列/springboot搭建.md b/springboot系列/springboot搭建.md
index dcd42c3..d923c71 100644
--- a/springboot系列/springboot搭建.md
+++ b/springboot系列/springboot搭建.md
@@ -1,48 +1,48 @@
- 前面的博客有说到spring boot搭建见另一篇博文，其实那篇博文还没写，现在来填个坑。我们使用spring initializr来构建，idea和eclipse都支持这种方式，构建过程类似，这里以idea为例，详细记录构建过程。
-
-###1.选择spring initializr
-
-
-
-next
-
-#### 2.设置参数
-
-
-
-next
-
-#### 3.选择依赖
-
- 在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖
-
-
-
-这里我们选择web搭建一个简单的REST风格demo。然后next。
-
-####4.设置项目存放地址
-
-
-
-这样就成功构建了一个springboot项目。
-
-#### 5.测试
-
- 现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下：
-
-
-
-HelloController代码如下：
-
-```java
-@RestController
-@RequestMapping("/home")
-public class HelloController{
- @GetMapping("/hello")
- public String sayHello(){
- return "hello";
- }
-}
-```
-
+ 前面的博客有说到spring boot搭建见另一篇博文，其实那篇博文还没写，现在来填个坑。我们使用spring initializr来构建，idea和eclipse都支持这种方式，构建过程类似，这里以idea为例，详细记录构建过程。
+
+###1.选择spring initializr
+
+
+
+next
+
+#### 2.设置参数
+
+
+
+next
+
+#### 3.选择依赖
+
+ 在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖
+
+
+
+这里我们选择web搭建一个简单的REST风格demo。然后next。
+
+####4.设置项目存放地址
+
+
+
+这样就成功构建了一个springboot项目。
+
+#### 5.测试
+
+ 现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下：
+
+
+
+HelloController代码如下：
+
+```java
+@RestController
+@RequestMapping("/home")
+public class HelloController{
+ @GetMapping("/hello")
+ public String sayHello(){
+ return "hello";
+ }
+}
+```
+
然后运行项目，访问localhost:8080/home/hello即可看到hello字符串。
\ No newline at end of file
diff --git a/springboot系列/springboot搭建/springboot搭建.md b/springboot系列/springboot搭建/springboot搭建.md
index b019272..0c60b29 100644
--- a/springboot系列/springboot搭建/springboot搭建.md
+++ b/springboot系列/springboot搭建/springboot搭建.md
@@ -1,48 +1,48 @@
- 前面的博客有说到spring boot搭建见另一篇博文，其实那篇博文还没写，现在来填个坑。我们使用spring initializr来构建，idea和eclipse都支持这种方式，构建过程类似，这里以idea为例，详细记录构建过程。
-
-###1.选择spring initializr
-
-
-
-next
-
-#### 2.设置参数
-
-
-
-next
-
-#### 3.选择依赖
-
- 在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖
-
-
-
-这里我们选择web搭建一个简单的REST风格demo。然后next。
-
-####4.设置项目存放地址
-
-
-
-这样就成功构建了一个springboot项目。
-
-#### 5.测试
-
- 现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下：
-
-
-
-HelloController代码如下：
-
-```java
-@RestController
-@RequestMapping("/home")
-public class HelloController{
- @GetMapping("/hello")
- public String sayHello(){
- return "hello";
- }
-}
-```
-
-然后运行项目，访问localhost:8080/home/hello即可看到hello字符串。
+ 前面的博客有说到spring boot搭建见另一篇博文，其实那篇博文还没写，现在来填个坑。我们使用spring initializr来构建，idea和eclipse都支持这种方式，构建过程类似，这里以idea为例，详细记录构建过程。
+
+###1.选择spring initializr
+
+
+
+next
+
+#### 2.设置参数
+
+
+
+next
+
+#### 3.选择依赖
+
+ 在这里选择spring boot版本和web依赖（忽略sql的依赖，如有需要[点击这里](f),单独将mybatis的整合)，后面也可手动编辑pom文件修改增加删除依赖
+
+
+
+这里我们选择web搭建一个简单的REST风格demo。然后next。
+
+####4.设置项目存放地址
+
+
+
+这样就成功构建了一个springboot项目。
+
+#### 5.测试
+
+ 现在新建一个controller包，包下新建一个HelloController,创建之后项目目录结构如下：
+
+
+
+HelloController代码如下：
+
+```java
+@RestController
+@RequestMapping("/home")
+public class HelloController{
+ @GetMapping("/hello")
+ public String sayHello(){
+ return "hello";
+ }
+}
+```
+
+然后运行项目，访问localhost:8080/home/hello即可看到hello字符串。
diff --git a/springboot系列/springsecurity/springboot+security整合1.md b/springboot系列/springsecurity/springboot+security整合1.md
index f3e7c41..aaee3fc 100644
--- a/springboot系列/springsecurity/springboot+security整合1.md
+++ b/springboot系列/springsecurity/springboot+security整合1.md
@@ -1,268 +1,268 @@
-**说明springboot版本2.0.3**
-
-##一、 介绍
-
- Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
-
-##二、 环境搭建
-
- 建立springboot2项目,加入security依赖,mybatis依赖
-```xml
-
- org.springframework.boot
- spring-boot-starter-security
-
-
- org.mybatis.spring.boot
- mybatis-spring-boot-starter
- 1.3.2
-
-
- mysql
- mysql-connector-java
- runtime
-
-```
- 数据库为传统的用户--角色--权限，权限表记录了url和method，springboot配置文件如下：
-```yml
-mybatis:
- type-aliases-package: com.example.demo.entity
-server:
- port: 8081
-spring:
- datasource:
- driver-class-name: com.mysql.jdbc.Driver
- url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
- username: root
- password: 123456
- http:
- encoding:
- charset: utf-8
- enabled: true
-```
-springboot启动类中加入如下代码,设置路由匹配规则。
-```java
-@Override
-protected void configurePathMatch(PathMatchConfigurer configurer) {
- configurer.setUseSuffixPatternMatch(false) //设置路由是否后缀匹配，譬如/user能够匹配/user.,/user.aa
- .setUseTrailingSlashMatch(false); //设置是否后缀路径匹配，比如/user能够匹配/user,/user/
-}
-```
-
-## 三、 security配置
-
- 默认情况下security是无需任何自定义配置就可使用的，我们不考虑这种方式，直接讲如何个性化登录过程。
-
-#### 1、 建立security配置文件,目前配置文件中还没有任何配置。
-```java
-@Configuration
-public class SecurityConfig extends WebSecurityConfigurerAdapter {
-}
-```
-
-#### 2、 个性化登录，security中的登录如下：
-![img][flow]
-- security需要一个user的实体类实现`UserDetails`接口,该实体类最后与系统中用户的实体类分开，代码如下：
-```java
-public class SecurityUser implements UserDetails{
- private static final long serialVersionUID = 1L;
- private String password;
- private String name;
- List authorities;
-
- public User(string name,string password) {
- this.id = id;
- this.password = password;
- this.name = name;
- this.age = age;
- }
-
- public void setAuthorities(List authorities) {
- this.authorities = authorities;
- }
-
- @Override
- public Collection getAuthorities() {
- return this.authorities;
- }
-
- @Override //获取校验用户名
- public String getUsername() {
- return String.valueOf(this.id);
- }
-
- @Override //获取校验用密码
- public String getPassword() {
- return password;
- }
-
- @Override //账户是否未过期
- public boolean isAccountNonExpired() {
- // TODO Auto-generated method stub
- return true;
- }
-
- @Override //账户是否未锁定
- public boolean isAccountNonLocked() {
- // TODO Auto-generated method stub
- return true;
- }
-
- @Override //帐户密码是否未过期，一般有的密码要求性高的系统会使用到，比较每隔一段时间就要求用户重置密码
- public boolean isCredentialsNonExpired() {
- // TODO Auto-generated method stub
- return true;
- }
-
- @Override //账户是否可用
- public boolean isEnabled() {
- // TODO Auto-generated method stub
- return true;
- }
-}
-```
-- 编写了实体类还需要编写一个服务类SecurityService实现`UserDetailsService`接口，重写loadByUsername方法，通过这个方法根据用户名获取用户信息，代码如下：
-```java
-@Component
-public class SecurityUserService implements UserDetailsService {
- @Autowired
- private JurisdictionMapper jurisdictionMapper;
- @Autowired
- private UserMapper userMapper;
- private Logger log = LoggerFactory.getLogger(this.getClass());
-
-
- @Override
- public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
- log.info("登录用户id为：{}",username);
- int id = Integer.valueOf(username);
- User user = userMapper.getById(id);
- if(user==null) {
- //抛出错误，用户不存在
- throw new UsernameNotFoundException("用户名 "+username+"不存在");
- }
- //获取用户权限
- List authorities = new ArrayList<>();
- List jurisdictions = jurisdictionMapper.selectByUserId(id);
- for(Jurisdiction item : jurisdictions) {
- GrantedAuthority authority = new MyGrantedAuthority(item.getMethod(),item.getUrl());
- authorities.add(authority);
- }
- SecurityUser securityUser = new SecurityUser(user.getName(),user.getPassword(),authority):
- user.setAuthorities(authorities);
- return securityUser;
- }
-}
-```
-- 通常我们会对密码进行加密，所有还要编写一个passwordencode类，实现PasswordEncoder接口，代码如下：
-```java
-@Component
-public class MyPasswordEncoder implements PasswordEncoder {
- private Logger log = LoggerFactory.getLogger(this.getClass());
-
- @Override //不清楚除了在下面方法用到还有什么用处
- public String encode(CharSequence rawPassword) {
- return StringUtil.StringToMD5(rawPassword.toString());
- }
-
- //判断密码是否匹配
- @Override
- public boolean matches(CharSequence rawPassword, String encodedPassword) {
- return encodedPassword.equals(this.encode(rawPassword));
- }
-}
-```
-
-#### 3、 编辑配置文件
-- 编写config Bean以使用上面定义的验证逻辑,securityUserService、myPasswordEncoder通过@Autowired引入。
-```java
-@Override
-protected void configure(AuthenticationManagerBuilder auth) throws Exception {
- auth.userDetailsService(securityUserService)
- .passwordEncoder(myPasswordEncoder);
-}
-```
-- 然后编写configure Bean（和上一个不一样，参数不同），实现security验证逻辑,代码如下：
-```java
-@Override
- protected void configure(HttpSecurity http) throws Exception {
- http
- .csrf() //跨站
- .disable() //关闭跨站检测
- .authorizeRequests()//验证策略策略链
- .antMatchers("/public/**").permitAll()//无需验证路径
- .antMatchers("/login").permitAll()//放行登录
- .antMatchers(HttpMethod.GET, "/user").hasAuthority("getAllUser")//拥有权限才可访问
- .antMatchers(HttpMethod.GET, "/user").hasAnyAuthority("1","2")//拥有任一权限即可访问
- //角色类似，hasRole(),hasAnyRole()
- .anyRequest().authenticated()
- .and()
- .formLogin()
- .loginPage("/public/unlogin") //未登录跳转页面,设置了authenticationentrypoint后无需设置未登录跳转页面
- .loginProcessingUrl("/public/login")//处理登录post请求接口，无需自己实现
- .successForwardUrl("/success")//登录成功转发接口
- .failureForwardUrl("/failed")//登录失败转发接口
- .usernameParameter("id") //修改用户名的表单name，默认为username
- .passwordParameter("password")//修改密码的表单name，默认为password
- .and()
- .logout()//自定义登出
- .logoutUrl("/public/logout") //自定义登出api，无需自己实现
- .logoutSuccessUrl("public/logoutSuccess")
- }
-```
-到这里便可实现security与springboot的基本整合。
-
-## 四、实现记住我功能
-
-#### 1、 建表
-
- 记住我功能需要数据库配合实现，首先要在数据库建一张表用户保存cookie和用户名，数据库建表语句如下：不能做修改
-```sql
-CREATE TABLE `persistent_logins` (
- `username` varchar(64) NOT NULL,
- `series` varchar(64) NOT NULL,
- `token` varchar(64) NOT NULL,
- `last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
- PRIMARY KEY (`series`)
-)
-```
-
-#### 2、 编写rememberMeservice Bean
- 代码如下：
-```java
- @Bean
- public RememberMeServices rememberMeServices(){
- JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
- jdbcTokenRepository.setDataSource(dataSource);
- PersistentTokenBasedRememberMeServices rememberMeServices =
- new PersistentTokenBasedRememberMeServices("INTERNAL_SECRET_KEY",securityUserService,jdbcTokenRepository);
- //还可设置许多其他属性
- rememberMeServices.setCookieName("kkkkk"); //客户端cookie名
- return rememberMeServices;
- }
-```
-dataSource为@Autowired引入
-
-#### 3、 配置文件设置remember
- 在config(HttpSecurity http)中加入记住我功能
-```java
-.rememberMe()
- .rememberMeServices(rememberMeServices())
- .key("INTERNAL_SECRET_KEY")
-```
-在登录表单中设置remember-me即可实现记住我功能。
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+**说明springboot版本2.0.3**
+
+##一、 介绍
+
+ Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC，DI（控制反转Inversion of Control ,DI:Dependency Injection 依赖注入）和AOP（面向切面编程）功能，为应用系统提供声明式的安全访问控制功能，减少了为企业系统安全控制编写大量重复代码的工作。
+
+##二、 环境搭建
+
+ 建立springboot2项目,加入security依赖,mybatis依赖
+```xml
+
+ org.springframework.boot
+ spring-boot-starter-security
+
+
+ org.mybatis.spring.boot
+ mybatis-spring-boot-starter
+ 1.3.2
+
+
+ mysql
+ mysql-connector-java
+ runtime
+
+```
+ 数据库为传统的用户--角色--权限，权限表记录了url和method，springboot配置文件如下：
+```yml
+mybatis:
+ type-aliases-package: com.example.demo.entity
+server:
+ port: 8081
+spring:
+ datasource:
+ driver-class-name: com.mysql.jdbc.Driver
+ url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
+ username: root
+ password: 123456
+ http:
+ encoding:
+ charset: utf-8
+ enabled: true
+```
+springboot启动类中加入如下代码,设置路由匹配规则。
+```java
+@Override
+protected void configurePathMatch(PathMatchConfigurer configurer) {
+ configurer.setUseSuffixPatternMatch(false) //设置路由是否后缀匹配，譬如/user能够匹配/user.,/user.aa
+ .setUseTrailingSlashMatch(false); //设置是否后缀路径匹配，比如/user能够匹配/user,/user/
+}
+```
+
+## 三、 security配置
+
+ 默认情况下security是无需任何自定义配置就可使用的，我们不考虑这种方式，直接讲如何个性化登录过程。
+
+#### 1、 建立security配置文件,目前配置文件中还没有任何配置。
+```java
+@Configuration
+public class SecurityConfig extends WebSecurityConfigurerAdapter {
+}
+```
+
+#### 2、 个性化登录，security中的登录如下：
+![img][flow]
+- security需要一个user的实体类实现`UserDetails`接口,该实体类最后与系统中用户的实体类分开，代码如下：
+```java
+public class SecurityUser implements UserDetails{
+ private static final long serialVersionUID = 1L;
+ private String password;
+ private String name;
+ List authorities;
+
+ public User(string name,string password) {
+ this.id = id;
+ this.password = password;
+ this.name = name;
+ this.age = age;
+ }
+
+ public void setAuthorities(List authorities) {
+ this.authorities = authorities;
+ }
+
+ @Override
+ public Collection getAuthorities() {
+ return this.authorities;
+ }
+
+ @Override //获取校验用户名
+ public String getUsername() {
+ return String.valueOf(this.id);
+ }
+
+ @Override //获取校验用密码
+ public String getPassword() {
+ return password;
+ }
+
+ @Override //账户是否未过期
+ public boolean isAccountNonExpired() {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override //账户是否未锁定
+ public boolean isAccountNonLocked() {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override //帐户密码是否未过期，一般有的密码要求性高的系统会使用到，比较每隔一段时间就要求用户重置密码
+ public boolean isCredentialsNonExpired() {
+ // TODO Auto-generated method stub
+ return true;
+ }
+
+ @Override //账户是否可用
+ public boolean isEnabled() {
+ // TODO Auto-generated method stub
+ return true;
+ }
+}
+```
+- 编写了实体类还需要编写一个服务类SecurityService实现`UserDetailsService`接口，重写loadByUsername方法，通过这个方法根据用户名获取用户信息，代码如下：
+```java
+@Component
+public class SecurityUserService implements UserDetailsService {
+ @Autowired
+ private JurisdictionMapper jurisdictionMapper;
+ @Autowired
+ private UserMapper userMapper;
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+
+
+ @Override
+ public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
+ log.info("登录用户id为：{}",username);
+ int id = Integer.valueOf(username);
+ User user = userMapper.getById(id);
+ if(user==null) {
+ //抛出错误，用户不存在
+ throw new UsernameNotFoundException("用户名 "+username+"不存在");
+ }
+ //获取用户权限
+ List authorities = new ArrayList<>();
+ List jurisdictions = jurisdictionMapper.selectByUserId(id);
+ for(Jurisdiction item : jurisdictions) {
+ GrantedAuthority authority = new MyGrantedAuthority(item.getMethod(),item.getUrl());
+ authorities.add(authority);
+ }
+ SecurityUser securityUser = new SecurityUser(user.getName(),user.getPassword(),authority):
+ user.setAuthorities(authorities);
+ return securityUser;
+ }
+}
+```
+- 通常我们会对密码进行加密，所有还要编写一个passwordencode类，实现PasswordEncoder接口，代码如下：
+```java
+@Component
+public class MyPasswordEncoder implements PasswordEncoder {
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+
+ @Override //不清楚除了在下面方法用到还有什么用处
+ public String encode(CharSequence rawPassword) {
+ return StringUtil.StringToMD5(rawPassword.toString());
+ }
+
+ //判断密码是否匹配
+ @Override
+ public boolean matches(CharSequence rawPassword, String encodedPassword) {
+ return encodedPassword.equals(this.encode(rawPassword));
+ }
+}
+```
+
+#### 3、 编辑配置文件
+- 编写config Bean以使用上面定义的验证逻辑,securityUserService、myPasswordEncoder通过@Autowired引入。
+```java
+@Override
+protected void configure(AuthenticationManagerBuilder auth) throws Exception {
+ auth.userDetailsService(securityUserService)
+ .passwordEncoder(myPasswordEncoder);
+}
+```
+- 然后编写configure Bean（和上一个不一样，参数不同），实现security验证逻辑,代码如下：
+```java
+@Override
+ protected void configure(HttpSecurity http) throws Exception {
+ http
+ .csrf() //跨站
+ .disable() //关闭跨站检测
+ .authorizeRequests()//验证策略策略链
+ .antMatchers("/public/**").permitAll()//无需验证路径
+ .antMatchers("/login").permitAll()//放行登录
+ .antMatchers(HttpMethod.GET, "/user").hasAuthority("getAllUser")//拥有权限才可访问
+ .antMatchers(HttpMethod.GET, "/user").hasAnyAuthority("1","2")//拥有任一权限即可访问
+ //角色类似，hasRole(),hasAnyRole()
+ .anyRequest().authenticated()
+ .and()
+ .formLogin()
+ .loginPage("/public/unlogin") //未登录跳转页面,设置了authenticationentrypoint后无需设置未登录跳转页面
+ .loginProcessingUrl("/public/login")//处理登录post请求接口，无需自己实现
+ .successForwardUrl("/success")//登录成功转发接口
+ .failureForwardUrl("/failed")//登录失败转发接口
+ .usernameParameter("id") //修改用户名的表单name，默认为username
+ .passwordParameter("password")//修改密码的表单name，默认为password
+ .and()
+ .logout()//自定义登出
+ .logoutUrl("/public/logout") //自定义登出api，无需自己实现
+ .logoutSuccessUrl("public/logoutSuccess")
+ }
+```
+到这里便可实现security与springboot的基本整合。
+
+## 四、实现记住我功能
+
+#### 1、 建表
+
+ 记住我功能需要数据库配合实现，首先要在数据库建一张表用户保存cookie和用户名，数据库建表语句如下：不能做修改
+```sql
+CREATE TABLE `persistent_logins` (
+ `username` varchar(64) NOT NULL,
+ `series` varchar(64) NOT NULL,
+ `token` varchar(64) NOT NULL,
+ `last_used` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+ PRIMARY KEY (`series`)
+)
+```
+
+#### 2、 编写rememberMeservice Bean
+ 代码如下：
+```java
+ @Bean
+ public RememberMeServices rememberMeServices(){
+ JdbcTokenRepositoryImpl jdbcTokenRepository = new JdbcTokenRepositoryImpl();
+ jdbcTokenRepository.setDataSource(dataSource);
+ PersistentTokenBasedRememberMeServices rememberMeServices =
+ new PersistentTokenBasedRememberMeServices("INTERNAL_SECRET_KEY",securityUserService,jdbcTokenRepository);
+ //还可设置许多其他属性
+ rememberMeServices.setCookieName("kkkkk"); //客户端cookie名
+ return rememberMeServices;
+ }
+```
+dataSource为@Autowired引入
+
+#### 3、 配置文件设置remember
+ 在config(HttpSecurity http)中加入记住我功能
+```java
+.rememberMe()
+ .rememberMeServices(rememberMeServices())
+ .key("INTERNAL_SECRET_KEY")
+```
+在登录表单中设置remember-me即可实现记住我功能。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
[flow]:data:image/jpeg;base64,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
\ No newline at end of file
diff --git a/springboot系列/springsecurity/springboot+security整合2.md b/springboot系列/springsecurity/springboot+security整合2.md
index 262260c..e995ad8 100644
--- a/springboot系列/springsecurity/springboot+security整合2.md
+++ b/springboot系列/springsecurity/springboot+security整合2.md
@@ -1,89 +1,89 @@
- 紧接着上一篇，上一篇中登录验证都由security帮助我们完成了，如果我们想要增加一个验证码登录或者其它的自定义校验就没办法了，因此这一篇讲解如何实现这个功能。
-
-##一、 实现自定义登录校验类
-
- 继承UsernamePasswordAuthenticationFilter类来拓展登录校验，代码如下：
-```java
-public class MyUsernamePasswordAuthentication extends UsernamePasswordAuthenticationFilter{
-
- private Logger log = LoggerFactory.getLogger(this.getClass());
-
- @Override
- public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
- throws AuthenticationException {
- //我们可以在这里进行额外的验证，如果验证失败抛出继承AuthenticationException的自定义错误。
- log.info("在这里进行验证码判断");
- //只要最终的验证是账号密码形式就无需修改后续过程
- return super.attemptAuthentication(request, response);
- }
-
- @Override
- public void setAuthenticationManager(AuthenticationManager authenticationManager) {
- // TODO Auto-generated method stub
- super.setAuthenticationManager(authenticationManager);
- }
-}
-```
-
-##二、 将自定义登录配置到security中
- 编写自定义登录过滤器后，configure Bean修改为如下：
-```java
- @Override
- protected void configure(HttpSecurity http) throws Exception {
- http
- .csrf() //跨站
- .disable() //关闭跨站检测
- //自定义鉴权过程，无需下面设置
- .authorizeRequests()//验证策略
- .antMatchers("/public/**").permitAll()//无需验证路径
- .antMatchers("/user/**").permitAll()
- .antMatchers("/login").permitAll()//放行登录
- .antMatchers(HttpMethod.GET, "/user").hasAuthority("getAllUser")//拥有权限才可访问
- .antMatchers(HttpMethod.GET, "/user").hasAnyAuthority("1","2")//拥有任一权限即可访问
- //角色类似，hasRole(),hasAnyRole()
- .anyRequest().authenticated()
- .and()
- //自定义异常处理
- .exceptionHandling()
- .authenticationEntryPoint(myAuthenticationEntryPoint)//未登录处理
- .accessDeniedHandler(myAccessDeniedHandler)//权限不足处理
- .and()
- //加入自定义登录校验
- .addFilterBefore(myUsernamePasswordAuthentication(),UsernamePasswordAuthenticationFilter.class)
- .rememberMe()//默认放在内存中
- .rememberMeServices(rememberMeServices())
- .key("INTERNAL_SECRET_KEY")
-// 重写usernamepasswordauthenticationFilter后，下面的formLogin()设置将失效，需要手动设置到个性化过滤器中
-// .and()
-// .formLogin()
-// .loginPage("/public/unlogin") //未登录跳转页面,设置了authenticationentrypoint后无需设置未登录跳转页面
-// .loginProcessingUrl("/public/login")//登录api
-// .successForwardUrl("/success")
-// .failureForwardUrl("/failed")
-// .usernameParameter("id")
-// .passwordParameter("password")
-// .failureHandler(myAuthFailedHandle) //登录失败处理
-// .successHandler(myAuthSuccessHandle)//登录成功处理
-// .usernameParameter("id")
- .and()
- .logout()//自定义登出
- .logoutUrl("/public/logout")
- .logoutSuccessUrl("public/logoutSuccess")
- .logoutSuccessHandler(myLogoutSuccessHandle);
- }
-```
-然后再编写Bean，代码如下：
-```java
-@Bean
-public MyUsernamePasswordAuthentication myUsernamePasswordAuthentication(){
- MyUsernamePasswordAuthentication myUsernamePasswordAuthentication = new MyUsernamePasswordAuthentication();
- myUsernamePasswordAuthentication.setAuthenticationFailureHandler(myAuthFailedHandle); //设置登录失败处理类
- myUsernamePasswordAuthentication.setAuthenticationSuccessHandler(myAuthSuccessHandle);//设置登录成功处理类
- myUsernamePasswordAuthentication.setFilterProcessesUrl("/public/login");
- myUsernamePasswordAuthentication.setRememberMeServices(rememberMeServices()); //设置记住我
- myUsernamePasswordAuthentication.setUsernameParameter("id");
- myUsernamePasswordAuthentication.setPasswordParameter("password");
- return myUsernamePasswordAuthentication;
-}
-```
+ 紧接着上一篇，上一篇中登录验证都由security帮助我们完成了，如果我们想要增加一个验证码登录或者其它的自定义校验就没办法了，因此这一篇讲解如何实现这个功能。
+
+##一、 实现自定义登录校验类
+
+ 继承UsernamePasswordAuthenticationFilter类来拓展登录校验，代码如下：
+```java
+public class MyUsernamePasswordAuthentication extends UsernamePasswordAuthenticationFilter{
+
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+
+ @Override
+ public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
+ throws AuthenticationException {
+ //我们可以在这里进行额外的验证，如果验证失败抛出继承AuthenticationException的自定义错误。
+ log.info("在这里进行验证码判断");
+ //只要最终的验证是账号密码形式就无需修改后续过程
+ return super.attemptAuthentication(request, response);
+ }
+
+ @Override
+ public void setAuthenticationManager(AuthenticationManager authenticationManager) {
+ // TODO Auto-generated method stub
+ super.setAuthenticationManager(authenticationManager);
+ }
+}
+```
+
+##二、 将自定义登录配置到security中
+ 编写自定义登录过滤器后，configure Bean修改为如下：
+```java
+ @Override
+ protected void configure(HttpSecurity http) throws Exception {
+ http
+ .csrf() //跨站
+ .disable() //关闭跨站检测
+ //自定义鉴权过程，无需下面设置
+ .authorizeRequests()//验证策略
+ .antMatchers("/public/**").permitAll()//无需验证路径
+ .antMatchers("/user/**").permitAll()
+ .antMatchers("/login").permitAll()//放行登录
+ .antMatchers(HttpMethod.GET, "/user").hasAuthority("getAllUser")//拥有权限才可访问
+ .antMatchers(HttpMethod.GET, "/user").hasAnyAuthority("1","2")//拥有任一权限即可访问
+ //角色类似，hasRole(),hasAnyRole()
+ .anyRequest().authenticated()
+ .and()
+ //自定义异常处理
+ .exceptionHandling()
+ .authenticationEntryPoint(myAuthenticationEntryPoint)//未登录处理
+ .accessDeniedHandler(myAccessDeniedHandler)//权限不足处理
+ .and()
+ //加入自定义登录校验
+ .addFilterBefore(myUsernamePasswordAuthentication(),UsernamePasswordAuthenticationFilter.class)
+ .rememberMe()//默认放在内存中
+ .rememberMeServices(rememberMeServices())
+ .key("INTERNAL_SECRET_KEY")
+// 重写usernamepasswordauthenticationFilter后，下面的formLogin()设置将失效，需要手动设置到个性化过滤器中
+// .and()
+// .formLogin()
+// .loginPage("/public/unlogin") //未登录跳转页面,设置了authenticationentrypoint后无需设置未登录跳转页面
+// .loginProcessingUrl("/public/login")//登录api
+// .successForwardUrl("/success")
+// .failureForwardUrl("/failed")
+// .usernameParameter("id")
+// .passwordParameter("password")
+// .failureHandler(myAuthFailedHandle) //登录失败处理
+// .successHandler(myAuthSuccessHandle)//登录成功处理
+// .usernameParameter("id")
+ .and()
+ .logout()//自定义登出
+ .logoutUrl("/public/logout")
+ .logoutSuccessUrl("public/logoutSuccess")
+ .logoutSuccessHandler(myLogoutSuccessHandle);
+ }
+```
+然后再编写Bean，代码如下：
+```java
+@Bean
+public MyUsernamePasswordAuthentication myUsernamePasswordAuthentication(){
+ MyUsernamePasswordAuthentication myUsernamePasswordAuthentication = new MyUsernamePasswordAuthentication();
+ myUsernamePasswordAuthentication.setAuthenticationFailureHandler(myAuthFailedHandle); //设置登录失败处理类
+ myUsernamePasswordAuthentication.setAuthenticationSuccessHandler(myAuthSuccessHandle);//设置登录成功处理类
+ myUsernamePasswordAuthentication.setFilterProcessesUrl("/public/login");
+ myUsernamePasswordAuthentication.setRememberMeServices(rememberMeServices()); //设置记住我
+ myUsernamePasswordAuthentication.setUsernameParameter("id");
+ myUsernamePasswordAuthentication.setPasswordParameter("password");
+ return myUsernamePasswordAuthentication;
+}
+```
完成。
\ No newline at end of file
diff --git a/springboot系列/springsecurity/springboot+security整合3.md b/springboot系列/springsecurity/springboot+security整合3.md
index d731953..8ee3105 100644
--- a/springboot系列/springsecurity/springboot+security整合3.md
+++ b/springboot系列/springsecurity/springboot+security整合3.md
@@ -1,235 +1,235 @@
- 这篇讲解如何自定义鉴权过程，实现根据数据库查询出的url和method是否匹配当前请求的url和method来决定有没有权限。security鉴权过程如下：
-![鉴权流程][鉴权流程]
-
-##一、 重写metadataSource类
-
-1. 编写MyGranteAuthority类，让权限包含url和method两个部分。
-```java
-public class MyGrantedAuthority implements GrantedAuthority {
- private String method;
- private String url;
-
- public MyGrantedAuthority(String method, String url) {
- this.method = method;
- this.url = url;
- }
-
- @Override
- public String getAuthority() {
- return url;
- }
-
- public String getMethod() {
- return method;
- }
-
- public String getUrl() {
- return url;
- }
-
- @Override
- public boolean equals(Object obj) {
- if(this==obj) return true;
- if(obj==null||getClass()!= obj.getClass()) return false;
- MyGrantedAuthority grantedAuthority = (MyGrantedAuthority)obj;
- if(this.method.equals(grantedAuthority.getMethod())&&this.url.equals(grantedAuthority.getUrl()))
- return true;
- return false;
- }
-}
-```
-2. 编写MyConfigAttribute类，实现ConfigAttribute接口，代码如下：
-```java
-public class MyConfigAttribute implements ConfigAttribute {
- private HttpServletRequest httpServletRequest;
- private MyGrantedAuthority myGrantedAuthority;
-
- public MyConfigAttribute(HttpServletRequest httpServletRequest) {
- this.httpServletRequest = httpServletRequest;
- }
-
- public MyConfigAttribute(HttpServletRequest httpServletRequest, MyGrantedAuthority myGrantedAuthority) {
- this.httpServletRequest = httpServletRequest;
- this.myGrantedAuthority = myGrantedAuthority;
- }
-
- public HttpServletRequest getHttpServletRequest() {
- return httpServletRequest;
- }
-
- @Override
- public String getAttribute() {
- return myGrantedAuthority.getUrl();
- }
-
- public MyGrantedAuthority getMyGrantedAuthority() {
- return myGrantedAuthority;
- }
-}
-```
-3. 编写MySecurityMetadataSource类，获取当前url所需要的权限
-```java
-@Component
-public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
-
- private Logger log = LoggerFactory.getLogger(this.getClass());
-
- @Autowired
- private JurisdictionMapper jurisdictionMapper;
- private List jurisdictions;
-
- private void loadResource() {
- this.jurisdictions = jurisdictionMapper.selectAllPermission();
- }
-
-
- @Override
- public Collection getAttributes(Object object) throws IllegalArgumentException {
- if (jurisdictions == null) this.loadResource();
- HttpServletRequest request = ((FilterInvocation) object).getRequest();
- Set allConfigAttribute = new HashSet<>();
- AntPathRequestMatcher matcher;
- for (Jurisdiction jurisdiction : jurisdictions) {
- //使用AntPathRequestMatcher比较可让url支持ant风格,例如/user/*/a
- //*匹配一个或多个字符，**匹配任意字符或目录
- matcher = new AntPathRequestMatcher(jurisdiction.getUrl(), jurisdiction.getMethod());
- if (matcher.matches(request)) {
- ConfigAttribute configAttribute = new MyConfigAttribute(request,new MyGrantedAuthority(jurisdiction.getMethod(),jurisdiction.getUrl()));
- allConfigAttribute.add(configAttribute);
- //这里是获取到一个权限就返回,根据校验规则也可获取多个然后返回
- return allConfigAttribute;
- }
- }
- //未匹配到，说明无需权限验证
- return null;
- }
-
- @Override
- public Collection getAllConfigAttributes() {
- return null;
- }
-
- @Override
- public boolean supports(Class clazz) {
- return FilterInvocation.class.isAssignableFrom(clazz);
- }
-}
-```
-
-##二、 编写MyAccessDecisionManager类
-
- 实现AccessDecisionManager接口以实现权限判断,直接return说明验证通过，如不通过需要抛出对应错误，代码如下：
-```java
-@Component
-public class MyAccessDecisionManager implements AccessDecisionManager{
- private Logger log = LoggerFactory.getLogger(this.getClass());
-
- @Override
- public void decide(Authentication authentication, Object object, Collection configAttributes)
- throws AccessDeniedException, InsufficientAuthenticationException {
- //无需验证放行
- if(configAttributes==null || configAttributes.size()==0)
- return;
- if(!authentication.isAuthenticated()){
- throw new InsufficientAuthenticationException("未登录");
- }
- Collection authorities = authentication.getAuthorities();
- for(ConfigAttribute attribute : configAttributes){
- MyConfigAttribute urlConfigAttribute = (MyConfigAttribute)attribute;
- for(GrantedAuthority authority: authorities){
- MyGrantedAuthority myGrantedAuthority = (MyGrantedAuthority)authority;
- if(urlConfigAttribute.getMyGrantedAuthority().equals(myGrantedAuthority))
- return;
- }
- }
- throw new AccessDeniedException("无权限");
- }
-
- @Override
- public boolean supports(ConfigAttribute attribute) {
- return true;
- }
-
- @Override
- public boolean supports(Class clazz) {
- return true;
- }
-}
-```
-
-##三、 编写MyFilterSecurityInterceptor类
- 该类继承AbstractSecurityInterceptor类，实现Filter接口,代码如下：
-```java
-@Component
-public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter {
-
- //注入上面编写的两个类
- @Autowired
- private MySecurityMetadataSource mySecurityMetadataSource;
-
- @Autowired
- public void setMyAccessDecisionManager(MyAccessDecisionManager myAccessDecisionManager) {
- super.setAccessDecisionManager(myAccessDecisionManager);
- }
-
- @Override
- public void init(FilterConfig arg0) throws ServletException {
- }
-
-
- @Override
- public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
- FilterInvocation fi = new FilterInvocation(request, response, chain);
- invoke(fi);
- }
-
- public void invoke(FilterInvocation fi) throws IOException, ServletException {
- //这里进行权限验证
- InterceptorStatusToken token = super.beforeInvocation(fi);
- try {
- fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
- } finally {
- super.afterInvocation(token, null);
- }
- }
-
- @Override
- public void destroy() {
- }
-
- @Override
- public Class getSecureObjectClass() {
- return FilterInvocation.class;
- }
-
- @Override
- public SecurityMetadataSource obtainSecurityMetadataSource() {
- return this.mySecurityMetadataSource;
- }
-}
-```
-
-## 四、 加入到security的过滤器链中
-```java
-.addFilterBefore(urlFilterSecurityInterceptor,FilterSecurityInterceptor.class)
-```
-完成
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+ 这篇讲解如何自定义鉴权过程，实现根据数据库查询出的url和method是否匹配当前请求的url和method来决定有没有权限。security鉴权过程如下：
+![鉴权流程][鉴权流程]
+
+##一、 重写metadataSource类
+
+1. 编写MyGranteAuthority类，让权限包含url和method两个部分。
+```java
+public class MyGrantedAuthority implements GrantedAuthority {
+ private String method;
+ private String url;
+
+ public MyGrantedAuthority(String method, String url) {
+ this.method = method;
+ this.url = url;
+ }
+
+ @Override
+ public String getAuthority() {
+ return url;
+ }
+
+ public String getMethod() {
+ return method;
+ }
+
+ public String getUrl() {
+ return url;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if(this==obj) return true;
+ if(obj==null||getClass()!= obj.getClass()) return false;
+ MyGrantedAuthority grantedAuthority = (MyGrantedAuthority)obj;
+ if(this.method.equals(grantedAuthority.getMethod())&&this.url.equals(grantedAuthority.getUrl()))
+ return true;
+ return false;
+ }
+}
+```
+2. 编写MyConfigAttribute类，实现ConfigAttribute接口，代码如下：
+```java
+public class MyConfigAttribute implements ConfigAttribute {
+ private HttpServletRequest httpServletRequest;
+ private MyGrantedAuthority myGrantedAuthority;
+
+ public MyConfigAttribute(HttpServletRequest httpServletRequest) {
+ this.httpServletRequest = httpServletRequest;
+ }
+
+ public MyConfigAttribute(HttpServletRequest httpServletRequest, MyGrantedAuthority myGrantedAuthority) {
+ this.httpServletRequest = httpServletRequest;
+ this.myGrantedAuthority = myGrantedAuthority;
+ }
+
+ public HttpServletRequest getHttpServletRequest() {
+ return httpServletRequest;
+ }
+
+ @Override
+ public String getAttribute() {
+ return myGrantedAuthority.getUrl();
+ }
+
+ public MyGrantedAuthority getMyGrantedAuthority() {
+ return myGrantedAuthority;
+ }
+}
+```
+3. 编写MySecurityMetadataSource类，获取当前url所需要的权限
+```java
+@Component
+public class MySecurityMetadataSource implements FilterInvocationSecurityMetadataSource {
+
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+
+ @Autowired
+ private JurisdictionMapper jurisdictionMapper;
+ private List jurisdictions;
+
+ private void loadResource() {
+ this.jurisdictions = jurisdictionMapper.selectAllPermission();
+ }
+
+
+ @Override
+ public Collection getAttributes(Object object) throws IllegalArgumentException {
+ if (jurisdictions == null) this.loadResource();
+ HttpServletRequest request = ((FilterInvocation) object).getRequest();
+ Set allConfigAttribute = new HashSet<>();
+ AntPathRequestMatcher matcher;
+ for (Jurisdiction jurisdiction : jurisdictions) {
+ //使用AntPathRequestMatcher比较可让url支持ant风格,例如/user/*/a
+ //*匹配一个或多个字符，**匹配任意字符或目录
+ matcher = new AntPathRequestMatcher(jurisdiction.getUrl(), jurisdiction.getMethod());
+ if (matcher.matches(request)) {
+ ConfigAttribute configAttribute = new MyConfigAttribute(request,new MyGrantedAuthority(jurisdiction.getMethod(),jurisdiction.getUrl()));
+ allConfigAttribute.add(configAttribute);
+ //这里是获取到一个权限就返回,根据校验规则也可获取多个然后返回
+ return allConfigAttribute;
+ }
+ }
+ //未匹配到，说明无需权限验证
+ return null;
+ }
+
+ @Override
+ public Collection getAllConfigAttributes() {
+ return null;
+ }
+
+ @Override
+ public boolean supports(Class clazz) {
+ return FilterInvocation.class.isAssignableFrom(clazz);
+ }
+}
+```
+
+##二、 编写MyAccessDecisionManager类
+
+ 实现AccessDecisionManager接口以实现权限判断,直接return说明验证通过，如不通过需要抛出对应错误，代码如下：
+```java
+@Component
+public class MyAccessDecisionManager implements AccessDecisionManager{
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+
+ @Override
+ public void decide(Authentication authentication, Object object, Collection configAttributes)
+ throws AccessDeniedException, InsufficientAuthenticationException {
+ //无需验证放行
+ if(configAttributes==null || configAttributes.size()==0)
+ return;
+ if(!authentication.isAuthenticated()){
+ throw new InsufficientAuthenticationException("未登录");
+ }
+ Collection authorities = authentication.getAuthorities();
+ for(ConfigAttribute attribute : configAttributes){
+ MyConfigAttribute urlConfigAttribute = (MyConfigAttribute)attribute;
+ for(GrantedAuthority authority: authorities){
+ MyGrantedAuthority myGrantedAuthority = (MyGrantedAuthority)authority;
+ if(urlConfigAttribute.getMyGrantedAuthority().equals(myGrantedAuthority))
+ return;
+ }
+ }
+ throw new AccessDeniedException("无权限");
+ }
+
+ @Override
+ public boolean supports(ConfigAttribute attribute) {
+ return true;
+ }
+
+ @Override
+ public boolean supports(Class clazz) {
+ return true;
+ }
+}
+```
+
+##三、 编写MyFilterSecurityInterceptor类
+ 该类继承AbstractSecurityInterceptor类，实现Filter接口,代码如下：
+```java
+@Component
+public class MyFilterSecurityInterceptor extends AbstractSecurityInterceptor implements Filter {
+
+ //注入上面编写的两个类
+ @Autowired
+ private MySecurityMetadataSource mySecurityMetadataSource;
+
+ @Autowired
+ public void setMyAccessDecisionManager(MyAccessDecisionManager myAccessDecisionManager) {
+ super.setAccessDecisionManager(myAccessDecisionManager);
+ }
+
+ @Override
+ public void init(FilterConfig arg0) throws ServletException {
+ }
+
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
+ FilterInvocation fi = new FilterInvocation(request, response, chain);
+ invoke(fi);
+ }
+
+ public void invoke(FilterInvocation fi) throws IOException, ServletException {
+ //这里进行权限验证
+ InterceptorStatusToken token = super.beforeInvocation(fi);
+ try {
+ fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
+ } finally {
+ super.afterInvocation(token, null);
+ }
+ }
+
+ @Override
+ public void destroy() {
+ }
+
+ @Override
+ public Class getSecureObjectClass() {
+ return FilterInvocation.class;
+ }
+
+ @Override
+ public SecurityMetadataSource obtainSecurityMetadataSource() {
+ return this.mySecurityMetadataSource;
+ }
+}
+```
+
+## 四、 加入到security的过滤器链中
+```java
+.addFilterBefore(urlFilterSecurityInterceptor,FilterSecurityInterceptor.class)
+```
+完成
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
[鉴权流程]:data:image/jpeg;base64,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
\ No newline at end of file
diff --git a/springboot系列/websocket/springboot整合websocket.md b/springboot系列/websocket/springboot整合websocket.md
index 2646a41..2e18a5d 100644
--- a/springboot系列/websocket/springboot整合websocket.md
+++ b/springboot系列/websocket/springboot整合websocket.md
@@ -1,205 +1,205 @@
-一、背景
-
- 我们都知道http协议只能浏览器单方面向服务器发起请求获得响应，服务器不能主动向浏览器推送消息。想要实现浏览器的主动推送有两种主流实现方式：
-
-- 轮询：缺点很多，但是实现简单
-- websocket：在浏览器和服务器之间建立tcp连接，实现全双工通信
-
- springboot使用websocket有两种方式，一种是实现简单的websocket，另外一种是实现**STOMP**协议。这一篇实现简单的websocket，STOMP下一篇在讲。
-
-**注意：如下都是针对使用springboot内置容器**
-
-二、实现
-
-1、依赖引入
-
- 要使用websocket关键是`@ServerEndpoint`这个注解，该注解是javaee标准中的注解,tomcat7及以上已经实现了,如果使用传统方法将war包部署到tomcat中，只需要引入如下javaee标准依赖即可：
-```xml
-
- javax
- javaee-api
- 7.0
- provided
-
-```
-如使用springboot内置容器,无需引入，springboot已经做了包含。我们只需引入如下依赖即可：
-```xml
-
- org.springframework.boot
- spring-boot-starter-websocket
- 1.5.3.RELEASE
- pom
-
-```
-
-2、注入Bean
-
- 首先注入一个**ServerEndpointExporter**Bean,该Bean会自动注册使用@ServerEndpoint注解申明的websocket endpoint。代码如下：
-```java
-@Configuration
-public class WebSocketConfig {
- @Bean
- public ServerEndpointExporter serverEndpointExporter(){
- return new ServerEndpointExporter();
- }
-}
-```
-
-3、申明endpoint
-
- 建立**MyWebSocket.java**类，在该类中处理websocket逻辑
-```java
-@ServerEndpoint(value = "/websocket") //接受websocket请求路径
-@Component //注册到spring容器中
-public class MyWebSocket {
-
-
- //保存所有在线socket连接
- private static Map webSocketMap = new LinkedHashMap<>();
-
- //记录当前在线数目
- private static int count=0;
-
- //当前连接（每个websocket连入都会创建一个MyWebSocket实例
- private Session session;
-
- private Logger log = LoggerFactory.getLogger(this.getClass());
- //处理连接建立
- @OnOpen
- public void onOpen(Session session){
- this.session=session;
- webSocketMap.put(session.getId(),this);
- addCount();
- log.info("新的连接加入：{}",session.getId());
- }
-
- //接受消息
- @OnMessage
- public void onMessage(String message,Session session){
- log.info("收到客户端{}消息：{}",session.getId(),message);
- try{
- this.sendMessage("收到消息："+message);
- }catch (Exception e){
- e.printStackTrace();
- }
- }
-
- //处理错误
- @OnError
- public void onError(Throwable error,Session session){
- log.info("发生错误{},{}",session.getId(),error.getMessage());
- }
-
- //处理连接关闭
- @OnClose
- public void onClose(){
- webSocketMap.remove(this.session.getId());
- reduceCount();
- log.info("连接关闭:{}",this.session.getId());
- }
-
- //群发消息
-
- //发送消息
- public void sendMessage(String message) throws IOException {
- this.session.getBasicRemote().sendText(message);
- }
-
- //广播消息
- public static void broadcast(){
- MyWebSocket.webSocketMap.forEach((k,v)->{
- try{
- v.sendMessage("这是一条测试广播");
- }catch (Exception e){
- }
- });
- }
-
- //获取在线连接数目
- public static int getCount(){
- return count;
- }
-
- //操作count，使用synchronized确保线程安全
- public static synchronized void addCount(){
- MyWebSocket.count++;
- }
-
- public static synchronized void reduceCount(){
- MyWebSocket.count--;
- }
-}
-```
-
-4、客户的实现
-
- 客户端使用h5原生websocket，部分浏览器可能不支持。代码如下：
-```html
-
-
-
- websocket测试
-
-
-
-
-
-
-
-
-
-```
-
-三、测试
-
- 建立一个controller测试群发，代码如下：
-```java
-@RestController
-public class HomeController {
-
- @GetMapping("/broadcast")
- public void broadcast(){
- MyWebSocket.broadcast();
- }
-}
-```
-然后打开上面的html，可以看到浏览器和服务器都输出连接成功的信息：
-```
-浏览器：
-Event {isTrusted: true, type: "open", target: WebSocket, currentTarget: WebSocket, eventPhase: 2, …}
-
-服务端：
-2018-08-01 14:05:34.727 INFO 12708 --- [nio-8080-exec-1] com.fxb.h5websocket.MyWebSocket : 新的连接加入：0
-```
-点击测试按钮，可在服务端看到如下输出：
-```
-2018-08-01 15:00:34.644 INFO 12708 --- [nio-8080-exec-6] com.fxb.h5websocket.MyWebSocket : 收到客户端2消息：这是一个测试数据
-```
-再次打开html页面，这样就有两个websocket客户端，然后在浏览器访问[localhost:8080/broadcast](localhost:8080/broadcast)测试群发功能,每个客户端都会输出如下信息：
-```
-MessageEvent {isTrusted: true, data: "这是一条测试广播", origin: "ws://localhost:8080", lastEventId: "", source: null, …}
-```
-
- 源码可在[github]()上下载，记得点赞，star哦
-
+一、背景
+
+ 我们都知道http协议只能浏览器单方面向服务器发起请求获得响应，服务器不能主动向浏览器推送消息。想要实现浏览器的主动推送有两种主流实现方式：
+
+- 轮询：缺点很多，但是实现简单
+- websocket：在浏览器和服务器之间建立tcp连接，实现全双工通信
+
+ springboot使用websocket有两种方式，一种是实现简单的websocket，另外一种是实现**STOMP**协议。这一篇实现简单的websocket，STOMP下一篇在讲。
+
+**注意：如下都是针对使用springboot内置容器**
+
+二、实现
+
+1、依赖引入
+
+ 要使用websocket关键是`@ServerEndpoint`这个注解，该注解是javaee标准中的注解,tomcat7及以上已经实现了,如果使用传统方法将war包部署到tomcat中，只需要引入如下javaee标准依赖即可：
+```xml
+
+ javax
+ javaee-api
+ 7.0
+ provided
+
+```
+如使用springboot内置容器,无需引入，springboot已经做了包含。我们只需引入如下依赖即可：
+```xml
+
+ org.springframework.boot
+ spring-boot-starter-websocket
+ 1.5.3.RELEASE
+ pom
+
+```
+
+2、注入Bean
+
+ 首先注入一个**ServerEndpointExporter**Bean,该Bean会自动注册使用@ServerEndpoint注解申明的websocket endpoint。代码如下：
+```java
+@Configuration
+public class WebSocketConfig {
+ @Bean
+ public ServerEndpointExporter serverEndpointExporter(){
+ return new ServerEndpointExporter();
+ }
+}
+```
+
+3、申明endpoint
+
+ 建立**MyWebSocket.java**类，在该类中处理websocket逻辑
+```java
+@ServerEndpoint(value = "/websocket") //接受websocket请求路径
+@Component //注册到spring容器中
+public class MyWebSocket {
+
+
+ //保存所有在线socket连接
+ private static Map webSocketMap = new LinkedHashMap<>();
+
+ //记录当前在线数目
+ private static int count=0;
+
+ //当前连接（每个websocket连入都会创建一个MyWebSocket实例
+ private Session session;
+
+ private Logger log = LoggerFactory.getLogger(this.getClass());
+ //处理连接建立
+ @OnOpen
+ public void onOpen(Session session){
+ this.session=session;
+ webSocketMap.put(session.getId(),this);
+ addCount();
+ log.info("新的连接加入：{}",session.getId());
+ }
+
+ //接受消息
+ @OnMessage
+ public void onMessage(String message,Session session){
+ log.info("收到客户端{}消息：{}",session.getId(),message);
+ try{
+ this.sendMessage("收到消息："+message);
+ }catch (Exception e){
+ e.printStackTrace();
+ }
+ }
+
+ //处理错误
+ @OnError
+ public void onError(Throwable error,Session session){
+ log.info("发生错误{},{}",session.getId(),error.getMessage());
+ }
+
+ //处理连接关闭
+ @OnClose
+ public void onClose(){
+ webSocketMap.remove(this.session.getId());
+ reduceCount();
+ log.info("连接关闭:{}",this.session.getId());
+ }
+
+ //群发消息
+
+ //发送消息
+ public void sendMessage(String message) throws IOException {
+ this.session.getBasicRemote().sendText(message);
+ }
+
+ //广播消息
+ public static void broadcast(){
+ MyWebSocket.webSocketMap.forEach((k,v)->{
+ try{
+ v.sendMessage("这是一条测试广播");
+ }catch (Exception e){
+ }
+ });
+ }
+
+ //获取在线连接数目
+ public static int getCount(){
+ return count;
+ }
+
+ //操作count，使用synchronized确保线程安全
+ public static synchronized void addCount(){
+ MyWebSocket.count++;
+ }
+
+ public static synchronized void reduceCount(){
+ MyWebSocket.count--;
+ }
+}
+```
+
+4、客户的实现
+
+ 客户端使用h5原生websocket，部分浏览器可能不支持。代码如下：
+```html
+
+
+
+ websocket测试
+
+
+
+
+
+
+
+
+
+```
+
+三、测试
+
+ 建立一个controller测试群发，代码如下：
+```java
+@RestController
+public class HomeController {
+
+ @GetMapping("/broadcast")
+ public void broadcast(){
+ MyWebSocket.broadcast();
+ }
+}
+```
+然后打开上面的html，可以看到浏览器和服务器都输出连接成功的信息：
+```
+浏览器：
+Event {isTrusted: true, type: "open", target: WebSocket, currentTarget: WebSocket, eventPhase: 2, …}
+
+服务端：
+2018-08-01 14:05:34.727 INFO 12708 --- [nio-8080-exec-1] com.fxb.h5websocket.MyWebSocket : 新的连接加入：0
+```
+点击测试按钮，可在服务端看到如下输出：
+```
+2018-08-01 15:00:34.644 INFO 12708 --- [nio-8080-exec-6] com.fxb.h5websocket.MyWebSocket : 收到客户端2消息：这是一个测试数据
+```
+再次打开html页面，这样就有两个websocket客户端，然后在浏览器访问[localhost:8080/broadcast](localhost:8080/broadcast)测试群发功能,每个客户端都会输出如下信息：
+```
+MessageEvent {isTrusted: true, data: "这是一条测试广播", origin: "ws://localhost:8080", lastEventId: "", source: null, …}
+```
+
+ 源码可在[github]()上下载，记得点赞，star哦
+
diff --git a/springboot系列/数据库/springboot整合mybatis.md b/springboot系列/数据库/springboot整合mybatis.md
index 861f322..f3cdc53 100644
--- a/springboot系列/数据库/springboot整合mybatis.md
+++ b/springboot系列/数据库/springboot整合mybatis.md
@@ -1,386 +1,386 @@
-## 写在前面
-
- 刚毕业的第一份工作是java开发，项目中需要用到mybatis，特此记录学习过程，这只是一个简单demo，mybatis用法很多不可能全部写出来，有更复杂的需求建议查看mybatis的官方中文文档，[点击跳转](http://www.mybatis.org/mybatis-3/zh/index.html)。下面时项目环境/版本。
-
-- 开发工具：IDEA
-- jdk版本：1.8
-- springboot版本：2.03
-
-其他依赖版本见下面pom.xml:
-
-```xml
-
-
- 4.0.0
-
- com.example
- mybatis-test
- 0.0.1-SNAPSHOT
- jar
-
- mybatis-test
- Demo project for Spring Boot
-
-
- org.springframework.boot
- spring-boot-starter-parent
- 2.0.3.RELEASE
-
-
-
-
- UTF-8
- UTF-8
- 1.8
-
-
-
-
- org.springframework.boot
- spring-boot-starter-web
-
-
- mysql
- mysql-connector-java
- runtime
-
-
-
- org.mybatis.spring.boot
- mybatis-spring-boot-starter
- 1.3.2
-
-
-
- com.alibaba
- druid-spring-boot-starter
- 1.1.9
-
-
-
- com.github.pagehelper
- pagehelper-spring-boot-starter
- 1.2.5
-
-
- org.springframework.boot
- spring-boot-starter-test
- test
-
-
-
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
-
-
-```
-
-## 1.创建项目
-
- 使用idea中的spring initializr生成maven项目，项目命令为mybatis-test，选择web，mysql，mybatis依赖，即可成功。（详细过程不赘述，如有需要学习springboot创建过程，可参考[这篇文章]()。
-
- 然后依照上面的pom文件，补齐缺少的依赖。接着创建包entity，service和mybatis映射文件夹mapper，创建。为了方便配置将application.properties改成application.yml。由于我们时REST接口，故不需要static和templates目录。修改完毕后的项目结构如下：
-
-![pic][pic1]
-
- 修改启动类，增加`@MapperScan("com.example.mybatistest.dao") `,以自动扫描dao目录，避免每个dao都手动加`@Mapper`注解。代码如下：
-
-```java
-@SpringBootApplication
-@MapperScan("com.example.mybatistest.dao")
-public class MybatisTestApplication {
- public static void main(String[] args) {
- SpringApplication.run(MybatisTestApplication.class, args);
- }
-}
-```
-
- 修改application.yml,配置项目，代码如下：
-
-```yml
-mybatis:
- #对应实体类路径
- type-aliases-package: com.example.mybatistest.entity
- #对应mapper映射文件路径
- mapper-locations: classpath:mapper/*.xml
-
-#pagehelper物理分页配置
-pagehelper:
- helper-dialect: mysql
- reasonable: true
- support-methods-arguments: true
- params: count=countSql
- returnPageInfo: check
-
-server:
- port: 8081
-
-spring:
- datasource:
- name: mysqlTest
- type: com.alibaba.druid.pool.DruidDataSource
- #druid连接池相关配置
- druid:
- #监控拦截统计的filters
- filters: stat
- driver-class-name: com.mysql.jdbc.Driver
- url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
- username: root
- password: 123456
- #配置初始化大小，最小，最大
- initial-size: 1
- min-idle: 1
- max-active: 20
- #获取连接等待超时时间
- max-wait: 6000
- #间隔多久检测一次需要关闭的空闲连接
- time-between-eviction-runs-millis: 60000
- #一个连接在池中的最小生存时间
- min-evictable-idle-time-millis: 300000
- #打开PSCache，并指定每个连接上PSCache的大小。oracle设置为true，mysql设置为false。分库分表设置较多推荐设置
- pool-prepared-statements: false
- max-pool-prepared-statement-per-connection-size: 20
- http:
- encoding:
- charset: utf-8
- enabled: true
-```
-
-## 2.编写代码
-
- 首先创建数据表，sql语句如下：
-
-```sql
-CREATE TABLE `user` (
- `id` int(11) NOT NULL AUTO_INCREMENT,
- `name` varchar(255) NOT NULL,
- `age` tinyint(4) NOT NULL DEFAULT '0',
- `password` varchar(255) NOT NULL DEFAULT '123456',
- PRIMARY KEY (`id`)
-) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8;
-```
-
- 然后在entity包中创建实体类User.java
-
-```java
-public class User {
- private int id;
- private String name;
- private int age;
- private String password;
-
- public User(int id, String name, int age, String password) {
- this.id = id;
- this.name = name;
- this.age = age;
- this.password = password;
- }
- public User(){}
- //getter setter自行添加
-}
-```
-
- 在dao包下创建UserDao.java
-
-```java
-public interface UserDao {
- //插入用户
- int insert(User user);
- //根据id查询
- User selectById(String id);
- //查询所有
- List selectAll();
-}
-```
-
- 在mapper文件夹下创建UserMapper.xml,具体的xml编写方法查看文首的官方文档。
-
-```xml
-
-
-
-
- user
-
-
- id,name,age,password
-
-
-
- INSERT INTO
-
- name,password,
-
- age
-
-
-
- #{name,jdbcType=VARCHAR},#{password},
-
- #{age}
-
-
-
-
-
-
-
-
-```
-
- 至此使用mybatis的代码编写完了，之后要用时调用dao接口中的方法即可。
-
-## 3.测试
-
- 我们通过编写service，controller然后使用postman进行测试。
-
- 首先编写UserService.java,代码如下：
-
-```java
-@Component
-public class UserService {
-
- @Autowired
- private UserDao userDao;
-
- public User getByUserId(String id){
- return userDao.selectById(id);
- }
- //获取全部用户
- public List getAll(){
- return userDao.selectAll();
- }
- //测试分页
- public PageInfo getAll(int pageNum,int pageSize){
- PageHelper.startPage(pageNum,pageSize);
- List users = userDao.selectAll();
- System.out.println(users.size());
- PageInfo result = new PageInfo<>(users);
- return result;
- }
-
- public int insert(User user){
- return userDao.insert(user);
- }
-
-}
-```
-
- 编写UserController.java
-
-```java
-@RestController
-public class UserController {
-
- @Autowired
- private UserService userService;
-
- @GetMapping("/user/{userId}")
- public User getUser(@PathVariable String userId){
- return userService.getByUserId(userId);
- }
-
- @GetMapping("/user")
- public List getAll(){
- return userService.getAll();
- }
-
- @GetMapping("/user/page/{pageNum}")
- public Object getPage(@PathVariable int pageNum,
- @RequestParam(name = "pageSize",required = false,defaultValue = "10") int pageSize){
- return userService.getAll(pageNum,pageSize);
- }
-
- @PostMapping("/user")
- public Object addOne(User user){
- userService.insert(user);
- return user;
- }
-}
-```
-
- 启动项目，通过postman进行请求测试，测试结果如下：
-
-- 插入数据：
-
-![插入][insert]
-
-- 查询数据
-
-![查询][select]
-
-
-
-- 分页查询
-
- ![分页查询][selectPage]
-
-
-
-## 4.注解编写sql
-
- 上面使用的是xml方式编写sql代码，其实mybatis也支持在注解中编写sql，这样可以避免编写复杂的xml查询文件，但同时也将sql语句耦合到了代码中，也不易实现复杂查询，因此多用于简单sql语句的编写。
-
- 要使用注解首先将applicaton.yml配置文件中的`mapper-locations: classpath:mapper/*.xml`注释掉。然后在UserDao.java中加入sql注解，代码如下：
-
-```java
-public interface UserDao {
- //插入用户
- @Insert("insert into user(name,age,password) value(#{name},#{age},#{password})")
- @Options(useGeneratedKeys=true,keyColumn="id",keyProperty="id")
- int insert(User user);
- //根据id查询
- @Select("select * from user where id=#{id}")
- User selectById(String id);
- //查询所有
- @Select("select * from user")
- List selectAll();
-}
-```
-
-然后重新启动项目测试，测试结果跟上面完全一样。
-
-```
-如果对你有帮助记得点赞、收藏哦！
-```
-
-
-
-
-
-
-
-
-
-
-
-
-
-[pic1]:data:image/png;base64,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
-[insert]:data:image/jpeg;base64,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
-
-
-
-[select]:data:image/jpeg;base64,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
-
-
-
-[selectPage]:data:image/jpeg;base64,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
-
+## 写在前面
+
+ 刚毕业的第一份工作是java开发，项目中需要用到mybatis，特此记录学习过程，这只是一个简单demo，mybatis用法很多不可能全部写出来，有更复杂的需求建议查看mybatis的官方中文文档，[点击跳转](http://www.mybatis.org/mybatis-3/zh/index.html)。下面时项目环境/版本。
+
+- 开发工具：IDEA
+- jdk版本：1.8
+- springboot版本：2.03
+
+其他依赖版本见下面pom.xml:
+
+```xml
+
+
+ 4.0.0
+
+ com.example
+ mybatis-test
+ 0.0.1-SNAPSHOT
+ jar
+
+ mybatis-test
+ Demo project for Spring Boot
+
+
+ org.springframework.boot
+ spring-boot-starter-parent
+ 2.0.3.RELEASE
+
+
+
+
+ UTF-8
+ UTF-8
+ 1.8
+
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+
+
+ mysql
+ mysql-connector-java
+ runtime
+
+
+
+ org.mybatis.spring.boot
+ mybatis-spring-boot-starter
+ 1.3.2
+
+
+
+ com.alibaba
+ druid-spring-boot-starter
+ 1.1.9
+
+
+
+ com.github.pagehelper
+ pagehelper-spring-boot-starter
+ 1.2.5
+
+
+ org.springframework.boot
+ spring-boot-starter-test
+ test
+
+
+
+
+
+
+ org.springframework.boot
+ spring-boot-maven-plugin
+
+
+
+
+```
+
+## 1.创建项目
+
+ 使用idea中的spring initializr生成maven项目，项目命令为mybatis-test，选择web，mysql，mybatis依赖，即可成功。（详细过程不赘述，如有需要学习springboot创建过程，可参考[这篇文章]()。
+
+ 然后依照上面的pom文件，补齐缺少的依赖。接着创建包entity，service和mybatis映射文件夹mapper，创建。为了方便配置将application.properties改成application.yml。由于我们时REST接口，故不需要static和templates目录。修改完毕后的项目结构如下：
+
+![pic][pic1]
+
+ 修改启动类，增加`@MapperScan("com.example.mybatistest.dao") `,以自动扫描dao目录，避免每个dao都手动加`@Mapper`注解。代码如下：
+
+```java
+@SpringBootApplication
+@MapperScan("com.example.mybatistest.dao")
+public class MybatisTestApplication {
+ public static void main(String[] args) {
+ SpringApplication.run(MybatisTestApplication.class, args);
+ }
+}
+```
+
+ 修改application.yml,配置项目，代码如下：
+
+```yml
+mybatis:
+ #对应实体类路径
+ type-aliases-package: com.example.mybatistest.entity
+ #对应mapper映射文件路径
+ mapper-locations: classpath:mapper/*.xml
+
+#pagehelper物理分页配置
+pagehelper:
+ helper-dialect: mysql
+ reasonable: true
+ support-methods-arguments: true
+ params: count=countSql
+ returnPageInfo: check
+
+server:
+ port: 8081
+
+spring:
+ datasource:
+ name: mysqlTest
+ type: com.alibaba.druid.pool.DruidDataSource
+ #druid连接池相关配置
+ druid:
+ #监控拦截统计的filters
+ filters: stat
+ driver-class-name: com.mysql.jdbc.Driver
+ url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
+ username: root
+ password: 123456
+ #配置初始化大小，最小，最大
+ initial-size: 1
+ min-idle: 1
+ max-active: 20
+ #获取连接等待超时时间
+ max-wait: 6000
+ #间隔多久检测一次需要关闭的空闲连接
+ time-between-eviction-runs-millis: 60000
+ #一个连接在池中的最小生存时间
+ min-evictable-idle-time-millis: 300000
+ #打开PSCache，并指定每个连接上PSCache的大小。oracle设置为true，mysql设置为false。分库分表设置较多推荐设置
+ pool-prepared-statements: false
+ max-pool-prepared-statement-per-connection-size: 20
+ http:
+ encoding:
+ charset: utf-8
+ enabled: true
+```
+
+## 2.编写代码
+
+ 首先创建数据表，sql语句如下：
+
+```sql
+CREATE TABLE `user` (
+ `id` int(11) NOT NULL AUTO_INCREMENT,
+ `name` varchar(255) NOT NULL,
+ `age` tinyint(4) NOT NULL DEFAULT '0',
+ `password` varchar(255) NOT NULL DEFAULT '123456',
+ PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=0 DEFAULT CHARSET=utf8;
+```
+
+ 然后在entity包中创建实体类User.java
+
+```java
+public class User {
+ private int id;
+ private String name;
+ private int age;
+ private String password;
+
+ public User(int id, String name, int age, String password) {
+ this.id = id;
+ this.name = name;
+ this.age = age;
+ this.password = password;
+ }
+ public User(){}
+ //getter setter自行添加
+}
+```
+
+ 在dao包下创建UserDao.java
+
+```java
+public interface UserDao {
+ //插入用户
+ int insert(User user);
+ //根据id查询
+ User selectById(String id);
+ //查询所有
+ List selectAll();
+}
+```
+
+ 在mapper文件夹下创建UserMapper.xml,具体的xml编写方法查看文首的官方文档。
+
+```xml
+
+
+
+
+ user
+
+
+ id,name,age,password
+
+
+
+ INSERT INTO
+
+ name,password,
+
+ age
+
+
+
+ #{name,jdbcType=VARCHAR},#{password},
+
+ #{age}
+
+
+
+
+
+
+
+
+```
+
+ 至此使用mybatis的代码编写完了，之后要用时调用dao接口中的方法即可。
+
+## 3.测试
+
+ 我们通过编写service，controller然后使用postman进行测试。
+
+ 首先编写UserService.java,代码如下：
+
+```java
+@Component
+public class UserService {
+
+ @Autowired
+ private UserDao userDao;
+
+ public User getByUserId(String id){
+ return userDao.selectById(id);
+ }
+ //获取全部用户
+ public List getAll(){
+ return userDao.selectAll();
+ }
+ //测试分页
+ public PageInfo getAll(int pageNum,int pageSize){
+ PageHelper.startPage(pageNum,pageSize);
+ List users = userDao.selectAll();
+ System.out.println(users.size());
+ PageInfo result = new PageInfo<>(users);
+ return result;
+ }
+
+ public int insert(User user){
+ return userDao.insert(user);
+ }
+
+}
+```
+
+ 编写UserController.java
+
+```java
+@RestController
+public class UserController {
+
+ @Autowired
+ private UserService userService;
+
+ @GetMapping("/user/{userId}")
+ public User getUser(@PathVariable String userId){
+ return userService.getByUserId(userId);
+ }
+
+ @GetMapping("/user")
+ public List getAll(){
+ return userService.getAll();
+ }
+
+ @GetMapping("/user/page/{pageNum}")
+ public Object getPage(@PathVariable int pageNum,
+ @RequestParam(name = "pageSize",required = false,defaultValue = "10") int pageSize){
+ return userService.getAll(pageNum,pageSize);
+ }
+
+ @PostMapping("/user")
+ public Object addOne(User user){
+ userService.insert(user);
+ return user;
+ }
+}
+```
+
+ 启动项目，通过postman进行请求测试，测试结果如下：
+
+- 插入数据：
+
+![插入][insert]
+
+- 查询数据
+
+![查询][select]
+
+
+
+- 分页查询
+
+ ![分页查询][selectPage]
+
+
+
+## 4.注解编写sql
+
+ 上面使用的是xml方式编写sql代码，其实mybatis也支持在注解中编写sql，这样可以避免编写复杂的xml查询文件，但同时也将sql语句耦合到了代码中，也不易实现复杂查询，因此多用于简单sql语句的编写。
+
+ 要使用注解首先将applicaton.yml配置文件中的`mapper-locations: classpath:mapper/*.xml`注释掉。然后在UserDao.java中加入sql注解，代码如下：
+
+```java
+public interface UserDao {
+ //插入用户
+ @Insert("insert into user(name,age,password) value(#{name},#{age},#{password})")
+ @Options(useGeneratedKeys=true,keyColumn="id",keyProperty="id")
+ int insert(User user);
+ //根据id查询
+ @Select("select * from user where id=#{id}")
+ User selectById(String id);
+ //查询所有
+ @Select("select * from user")
+ List selectAll();
+}
+```
+
+然后重新启动项目测试，测试结果跟上面完全一样。
+
+```
+如果对你有帮助记得点赞、收藏哦！
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+[pic1]:data:image/png;base64,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
+[insert]:data:image/jpeg;base64,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
+
+
+
+[select]:data:image/jpeg;base64,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
+
+
+
+[selectPage]:data:image/jpeg;base64,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
+
diff --git a/springboot系列/消息队列/springboot整合activeMQ（1）.md b/springboot系列/消息队列/springboot整合activeMQ（1）.md
index bac68fb..342f723 100644
--- a/springboot系列/消息队列/springboot整合activeMQ（1）.md
+++ b/springboot系列/消息队列/springboot整合activeMQ（1）.md
@@ -1,165 +1,165 @@
-# springboot与activeMQ入门（1）
-**说明：acitveMQ版本为：5.9.1，springboot版本为2.0.3**
-## 一. 下载安装（windows）
- 官方下载地址:[点我跳转](http://activemq.apache.org/download-archives.html),选择windows安装包下载,然后解压，解压后运行bin目录下的**activemq.bat**启动服务,无报错即可启动成功。默认管理地址为：[localhost:8161/admin](localhost:8161/admin),默认管理员账号密码为**admin**/**admin**。
-
-## 二. springboot整合
-
-### 1. 创建springboot项目
-
- 创建springboot web项目，加入spring-boot-starter-activemq依赖。
-```xml
-
- org.springframework.boot
- spring-boot-starter-activemq
-
-```
- 然后编辑配合文件，加上一个配置：61616为activeMQ的默认端口，暂时不做其他配置，使用默认值。
-```yml
-spring:
- activemq:
- broker-url: tcp://localhost:61616
-```
-### 2. 创建生产者消费者
- springboot中activeMQ的默认配置为**生产-消费者模式**，还有一种模式为**发布-订阅模式**后面再讲。项目目录如下：
- ![项目目录][pic1]
-
- 首先编写配置类Config.java，代码如下
-```java
-@Configuration
-public class Config {
- @Bean(name = "queue2")
- public Queue queue2(){
- return new ActiveMQQueue("active.queue2");
- }
-
- @Bean(name = "queue1")
- public Queue queue1(){
- return new ActiveMQQueue("active.queue1");
- }
-}
-```
-上面的代码建立了两个消息队列queue1，queue2,分别由queue1和queue2这两个Bean注入到Spring容器中。程序运行后会在activeMQ的管理页面->queue中看到如下：
-![队列][quenes]
-
- 生产者Producer.java代码如下：
-```java
-@RestController
-public class Producer {
- @Autowired
- private JmsMessagingTemplate jmsMessagingTemplate;
- @Autowired()
- @Qualifier("queue2")
- private Queue queue2;
- @Autowired()
- @Qualifier("queue1")
- private Queue queue1;
-
- @GetMapping("/queue2")
- public void sendMessage1(String message){
- jmsMessagingTemplate.convertAndSend(queue2,"I'm from queue2:"+message);
- }
-
- @GetMapping("/queue1")
- public void sendMessage2(String message){
- jmsMessagingTemplate.convertAndSend(queue1,"I'm from queue1:"+message);
- }
-}
-```
-上面的类创建了两个GET接口，访问这两个接口分别向queue1和queue2中发送消息。
-
-消费者Comsumer.java代码如下：
-```java
-@Component //将该类注解到Spring 容器中
-public class Comsumer {
- //接受消息队列1消息
- @JmsListener(destination = "active.queue1") //监听active.queue1消息队列
- public void readActiveQueue11(String message){
- System.out.println(1+message);
- }
-
- //接受消息队列1消息
- @JmsListener(destination = "active.queue1")
- public void readActiveQueue12(String message){
- System.out.println(2+message);
- }
-
- //接受消息队列2消息
- @JmsListener(destination = "active.queue2")
- public void readActiveQueue21(String message){
- System.out.println(1+message);
- }
-
- //接受消息队列2消息
- @JmsListener(destination = "active.queue2")
- public void readActiveQueue22(String message){
- System.out.println(2+message);
- }
-}
-```
-上面的代码定义了4个消费者，每两个消费一个消息队列。
-
-## 3. 运行
-
- 启动项目后分别向/queue1?message=niihao,/queue2?message=nihaoa发送http请求，然后我们可以在控制台中看到如下输出：
-```
-2I'm from queue2:nihaoa
-1I'm from queue2:nihaoa
-2I'm from queue1:nihao
-1I'm from queue1:nihao
-```
-消息都成功被消费者消费，从打印结果也可看出生产者消费者的一个特点：一个消息只会被一个消费者消费。同时在管理页面中可以看到：
-![运行结果][quenes1]
-每个消息队列有两个消费者，队列进入了三个消息，出了三个消息，说明消息都被消费掉了，如果注释掉消费者代码，再次运行，然后发送消息就会发现MessagesEnqueued数量大于MessagesDequeued，然后再让消费者上线会立即消费掉队列中的消息。
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-[quenes1]:data:image/png;base64,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
-
-[quenes]:data:image/png;base64,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
-
-
+# springboot与activeMQ入门（1）
+**说明：acitveMQ版本为：5.9.1，springboot版本为2.0.3**
+## 一. 下载安装（windows）
+ 官方下载地址:[点我跳转](http://activemq.apache.org/download-archives.html),选择windows安装包下载,然后解压，解压后运行bin目录下的**activemq.bat**启动服务,无报错即可启动成功。默认管理地址为：[localhost:8161/admin](localhost:8161/admin),默认管理员账号密码为**admin**/**admin**。
+
+## 二. springboot整合
+
+### 1. 创建springboot项目
+
+ 创建springboot web项目，加入spring-boot-starter-activemq依赖。
+```xml
+
+ org.springframework.boot
+ spring-boot-starter-activemq
+
+```
+ 然后编辑配合文件，加上一个配置：61616为activeMQ的默认端口，暂时不做其他配置，使用默认值。
+```yml
+spring:
+ activemq:
+ broker-url: tcp://localhost:61616
+```
+### 2. 创建生产者消费者
+ springboot中activeMQ的默认配置为**生产-消费者模式**，还有一种模式为**发布-订阅模式**后面再讲。项目目录如下：
+ ![项目目录][pic1]
+
+ 首先编写配置类Config.java，代码如下
+```java
+@Configuration
+public class Config {
+ @Bean(name = "queue2")
+ public Queue queue2(){
+ return new ActiveMQQueue("active.queue2");
+ }
+
+ @Bean(name = "queue1")
+ public Queue queue1(){
+ return new ActiveMQQueue("active.queue1");
+ }
+}
+```
+上面的代码建立了两个消息队列queue1，queue2,分别由queue1和queue2这两个Bean注入到Spring容器中。程序运行后会在activeMQ的管理页面->queue中看到如下：
+![队列][quenes]
+
+ 生产者Producer.java代码如下：
+```java
+@RestController
+public class Producer {
+ @Autowired
+ private JmsMessagingTemplate jmsMessagingTemplate;
+ @Autowired()
+ @Qualifier("queue2")
+ private Queue queue2;
+ @Autowired()
+ @Qualifier("queue1")
+ private Queue queue1;
+
+ @GetMapping("/queue2")
+ public void sendMessage1(String message){
+ jmsMessagingTemplate.convertAndSend(queue2,"I'm from queue2:"+message);
+ }
+
+ @GetMapping("/queue1")
+ public void sendMessage2(String message){
+ jmsMessagingTemplate.convertAndSend(queue1,"I'm from queue1:"+message);
+ }
+}
+```
+上面的类创建了两个GET接口，访问这两个接口分别向queue1和queue2中发送消息。
+
+消费者Comsumer.java代码如下：
+```java
+@Component //将该类注解到Spring 容器中
+public class Comsumer {
+ //接受消息队列1消息
+ @JmsListener(destination = "active.queue1") //监听active.queue1消息队列
+ public void readActiveQueue11(String message){
+ System.out.println(1+message);
+ }
+
+ //接受消息队列1消息
+ @JmsListener(destination = "active.queue1")
+ public void readActiveQueue12(String message){
+ System.out.println(2+message);
+ }
+
+ //接受消息队列2消息
+ @JmsListener(destination = "active.queue2")
+ public void readActiveQueue21(String message){
+ System.out.println(1+message);
+ }
+
+ //接受消息队列2消息
+ @JmsListener(destination = "active.queue2")
+ public void readActiveQueue22(String message){
+ System.out.println(2+message);
+ }
+}
+```
+上面的代码定义了4个消费者，每两个消费一个消息队列。
+
+## 3. 运行
+
+ 启动项目后分别向/queue1?message=niihao,/queue2?message=nihaoa发送http请求，然后我们可以在控制台中看到如下输出：
+```
+2I'm from queue2:nihaoa
+1I'm from queue2:nihaoa
+2I'm from queue1:nihao
+1I'm from queue1:nihao
+```
+消息都成功被消费者消费，从打印结果也可看出生产者消费者的一个特点：一个消息只会被一个消费者消费。同时在管理页面中可以看到：
+![运行结果][quenes1]
+每个消息队列有两个消费者，队列进入了三个消息，出了三个消息，说明消息都被消费掉了，如果注释掉消费者代码，再次运行，然后发送消息就会发现MessagesEnqueued数量大于MessagesDequeued，然后再让消费者上线会立即消费掉队列中的消息。
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[quenes1]:data:image/png;base64,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
+
+[quenes]:data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABIEAAADiCAMAAADuxycUAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAA4ppVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDUuMy1jMDExIDY2LjE0NTY2MSwgMjAxMi8wMi8wNi0xNDo1NjoyNyAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHhtbG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3VyY2VSZWYjIiB4bWxuczpkYz0iaHR0cDovL3B1cmwub3JnL2RjL2VsZW1lbnRzLzEuMS8iIHhtbG5zOnhtcD0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wLyIgeG1wTU06RG9jdW1lbnRJRD0ieG1wLmRpZDpDMTJBNEQ2NDhCRkExMUU4OTg0QkZCREMxQ0Y4NjcxQSIgeG1wTU06SW5zdGFuY2VJRD0ieG1wLmlpZDpDMTJBNEQ2MzhCRkExMUU4OTg0QkZCREMxQ0Y4NjcxQSIgeG1wOkNyZWF0b3JUb29sPSJBZG9iZSBQaG90b3Nob3AgQ1M2IFdpbmRvd3MiPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0idXVpZDpmYWY1YmRkNS1iYTNkLTExZGEtYWQzMS1kMzNkNzUxODJmMWIiIHN0UmVmOmRvY3VtZW50SUQ9IkExRDQ2NjA5OTQ0NUU2MTI5NjEwRjgwQkY1RTRGNDBGIi8+IDxkYzpjcmVhdG9yPiA8cmRmOlNlcT4gPHJkZjpsaT5meGI8L3JkZjpsaT4gPC9yZGY6U2VxPiA8L2RjOmNyZWF0b3I+IDwvcmRmOkRlc2NyaXB0aW9uPiA8L3JkZjpSREY+IDwveDp4bXBtZXRhPiA8P3hwYWNrZXQgZW5kPSJyIj8+IYGzIAAAAGBQTFRFz87O7ZJHVxg/6LTUnkFsopic1qKm8c+os2qUvtXO+/nt7vr6+dXy/u386MnW/u/N/Ozs19Lj2/n17Ozrua3F7frtuMi97e75emB0z+HYg42b9/f3/v7+8/PzzMzM////X+A8sAAAUkdJREFUeNrsnQ1jm7oOhhkESgwmJnzHhvz/f3n1SiYf3XbWdslKe61zuqYJSYyxHyRZkiOl3C+Enz1fXzuT3L5+9/fdS+cgQYIEeatEgUBBggT5PAL9ij+eKBcCyaG/Ysyr950DgYIECRIIFCRIkK9DIE+S8z2Bzq8sq58trV/ZYaFLgwQJEggUJEiQL0Kg82+ssN95nt2vXg4EChIkSCBQkCBBvhSBBl57V64onLX4v3COfs/41/FDepKOnOVv/Ivj3OzoKTnIhtX4IEGCfIhAoAcDyIFFjvHi3Cw4mQU5Z+LKzGoOM8c/e1GVrH9TIFCQIEHeb4UpZZRbYki7xiA2SilQpRO6nO35qhK5qzaEI1cmBQIFCRLkAwQiBCmiz/E40L8FWWOXqGgAyHuGzo2waIXPjeVFdAKHAoGCBAnybgJZ0oAAIIBnot+u6wbiCwhkXVEoGGkEGA+fwas9LASrAgfOwQ8UJEiQDxEIrDGnOD45uILkAfQaAosVHcgab3/hgJVE3gk9OOXBZAOBggQJ8n4dyKtAPQCjMnrUwSG04DmiESFoxKNm7vHLtfh3Ju708jrxi18fV1906NIgQYK8g0DEEHiha7aoXgCbYoRLWhFsToVr4niaSTWaXMSmmsYRUJbGgmy20RGpejuP8RAIFCRIkA9ZYeDOVBRHIdBepVCJDOlDJ8MuajxxKkoCTmEP9MTgMhwBGB0XYMgV41CISzp0aZAgQd6lAx2YO8fC60DHjoDTskV2UlXsZTwa/OOYQM24Pr0/yCp+8EQHCRLkQzqQcKfFuheUnbhQPZHFsuJjFtaBFJxEhnWgF9aBRuhA1tjj8dAKigZX8BJ96NIgQYK8Rwea1YGtrKFQhxEPFOtA5qIDgUBkZPFD0YGYQNba8kivqZPXgjhWMXRpkCBB3kEgOIImxortJg5JhA7UW7bC4IiO64Z0oLgx7IkWAvXs/dG6PaWRcQ1pSqks1avQpUGCBHmPDmTdgdfjnQQmEoFeeJGL9Jxx5hWwTtmxdoaemNgKqwe8eHKuHos2Th1SOqY1WSxIkCBB3kwgsqJIwxmsuHPqAn4hdgfFMK4IQQ2/0FgBVMw+6NbKIWNReDdQ8EQHCRLkQzpQpzi2mVfEjgUsqYM6Ftaqw/FoEfM8dJ1kinGWBh/dKfkLfysJlw7xQEGCBPkAgSQHVR3g4WkLSVRFeqr8+2oHn9/8FfLCggQJ8lECFYXVRKCUF7uYQMKYOwKpnwl0T6ggQYIE+W/5mUDWw0VbZcS309AT9tUePJfSZf9V0JUPDFAPEiTIe3QgW3RSisOQ1nNEcoX6aRewQKAgQYI8h0CsA1lNvzp1X/P5UoLM/pe9tRJKfocuDRIkyDsI1LQpSYt/158gQYIEeYb82hPtuDZQp16vdMm/RaE1dKCf1SC8jg+5tcgC1IMECfIeK8yvcXWqW+s/F78mUGF/QaAgQYIE+fhaWIBwkCBBPk8HCl0QJEiQQKAgQYIEAgUJEiRIIFCQIEECgYIECRIkEChIkCCBQEGCBAnyXQjEaWTfskvt5Z+ti2zwZl3oxfeNXPslLu/W2vmb9kSf2aJvC6EvcFbO3owGu0UKuc3Oa/cFCLS1dv62PZ+nAzmM+u8HINbt7Be4R94XNdigEsTbHmyxYZhJX+ACb62dv2lP9PsB+lyhpljZ5/l7iV1Pbev5Oc4PCGv54fY6UgbI9vKaLNut28+/2lY71/a8nUDRs8XaaImWJfqGMuPUNi7U84tchWiT12GJ7LzJfuP/uNu2fX031s61PW8n0PJsoe/GyP9ugsnsztGXaCkNDL7VbPI6RGfHmNzkJf4H8+P7tZPbsyUCWeHiN4SQO3+F4VkTgTBEI364vRYygTZ5h0HbvsKdcEvtXNuzHQJF35RA0CzsefvnxZ2/EmiD1yHCLWqj2hna9hWG4sbaye15P4H2e/YR0G88qir8K8/KTxTt9/IaRo3/Hd186X8qCvRyFfX9lCRJ1e+Tst8vPX8bPb9MPDnokCSPx4Vu1PTtPb3W1/RHTd9FRy9JRZLQa0uCfV730UKfw7KfFrnPs9Ojn6SFWRwndGRL7+Pziuj7cRh9SrT49j9SB+pLbkxF51fTieIcJrkjRPR4WejUamrynp7H4ehfOhY92UcVv7Peo8FxWi/oo4ciiE0dfFe0TP0SSb9V6I2Emkb9S21Mlkt7o6iP0ENTj+7q922N1kZ8nWvqxAf1370OhPb16An6ioWuar+f2qrv6YLytZYxOO3pT+nYfeRvuMyvmroRf9UPbtvN/KAeW+cCfy3ag+kSRfKDYbbnvx/bhje6OryPb53Ja8uk3+QM8Ftm9jpfcVi14PpH8rjiA/cXH2IURf89v3/Xng8SqHoegdAnU7+L42ya4hiEISIQgWge0G+mUJ2kRKCoJcxgkNFPTR1S0ZCjcVfxFkP0Gs3lnMYnjQB+Js77fV37jlrW/qp7T6AUnxC1/EkTfdPTCFSP1LqKvjGRTyeK9PRNNRpEs3jKcGrcfzi3Ev9i+mOM1Hwi6b6u6NSoP/j4ZxEI3UBXgcB8Yj7TNUerooS4CY5H4D71H1o57aUtQCd1G71Al+1pBELLWurFqI5SdAfxiK49jTuMBWoVrjnmyh4Papnx1B6MpJIaSKOobtrl2QSi7+x5NN0TqPq6BKK294LxK4GWTyDQVdbe+3lNhUahnGGER29r1ZVAdK4Jjf08WuId7nIl/dR0P65rogLNBZoDJ7xSln1fZhVu0gmOwun30CGiaKQZSp+RsT4Uneiz6niX0mfQnyU+c+np7on7ec0ESkpAoMb/Pe78dNja/kcTKKG5kydCIPp0fBM0jKSt6zrJamr/DvoaGoffQBQ1l6RJcFbVLj7VODVS8/rqiToQcb/CfWCpvb6VJFkEtZP1IvldEUqTjA5l7QyzDVcjq3rWmUhLAQQeTCAZ7xggKauC7SKa2uKvG7pL1EzWNNEONKaW/qzR1fSo9hPoGQSSudvv78f9dYZiUC5+3n4OgW5IcfnLc4SflDMQDceTinSAlu42/gpc53T01vn9dQi0rASKTwuNL8LHGBElYFOl8hw9mcY7ujOnUY8xSKBpaVbTa3000ev4OprgOXZbxJgkrSjHzB4rzP44XXr6HHpt2fPfmPF4lj+fjLuJn4x9+6NnEIgmD7QLOrWFvnNp5atbfCtOLYf1uESsy+0TnNoIy4ffg7ZCjaLDJ9ho/bMIBJzQVdihhcShBd15qtm0pZ5cuJMSVspOdGjOfdYvfOEynAW0zqV/oI62EoibiaaNScaXs8KX51FUxSPai5f85cd9qJLL2dbS8bXoyGn9bALRuUdXldvP+egLESi6J9Ay1RF0oHW+fx6BvDdQvlmshRu5+Il8y9+uQ1wItAiBaAQlux3Gdo6Rhp8cwx+aAEZ+WsUxGzOZzGGeHwvNlx3cODvSzumHPpAYlMICy3nap+zyAWlIl4C+UXkrDD87fC0dvePPvNiQDyYQTm3HNIEtxV9PbQFvWjyRy3kmNz9oLs0gtLZH17T4jJaGCDrr8QTiWQSHGH0NKVs7aEIJLgO6cCS+9DV6c2GFMkmk0WPbxru2gk4i14S0s2qaquThVlhf19yL1AdoWpvkfCXTFheP7njUwgQGegI0nWr41dZrvPDvHWtH0VMJtLJF7JTf2SfRP/ern89Xr0l0QciNtRWtvpU9Da1oubXOaMD1/fX1aHmAJfssAlXRVQd6L4GoD3iaZQyhtl4JlMhUzcCTJN2x4pLlYtCARjAClooIlC8XAp3quvcEmujojKYwfUTK8wSjc3f9bMx6nmd0z8R3PJNAPH1inrv89Zi7NH/4XKtcdLLcv8g0aqNpijDNy3pZCVRGDx7B9wTCZwsscRmyRNo7gtNwWVH7YdC0olAwuekuAP6j79HotGav0MMJRCZfvURr03ZyTwFnIuhmZI2NPBYir+tQv55KuYONSUt3L+5TdvI9m0D0JTV7Tr4sgZYbAkWk0ZEZ1t8QKPp7He5jBKKOrSPvqfWt8LoZ7p1Xn7TXc9/oo1oJBGMz6nd8L93F4k/2OlBLd+C0B2NO8S4CZUTDjun+C99zX2NK0CtMpR5aDu51YhKwQReL1UCv0F38tIdP2BMoe/EEot/5C+7hFy/7wwmUZWwnVKOcGjS4dvJtYj8QGRKZ2DV8bAYH6sJsYlssw/xLmPBL/yQCYXz5ZmSxb3Es2qH3Y+Ev0YwwqzOYjwKkmNnONhAvRz3aCmMDcQSjY6/VipoodhcscPqrFv0nxTWu/fiRpvNh7dP8QOxlROexW0rmxnUd7PZe/RmRBXcEqsRbsrZtbZ9oD/sbD3WS8PlUWINYn9+v/um/uhN+mECVNH//BAIJnXespcAvckMg6EDgCFtKGGkp9CH4F1t27MLGxp2YeotsMdaBqO9AoLxakpJm+k68kPCv7HbjHuN3JdCqA2E2Vc8lELQJaDreCmMC7UUHYquBowNyObWK24XVJjY568X3Q17d3MeeQSC6DVQMy7zyOlDlXbviu68qYRNTSHxxO2hzfD3gHZalyId7ojlUIhKO596mznhtHt9M1y3iX/Ct1f4uwwRisnuvdQpP1pMJBBt1jMeNE2h5M4EA+8lH4XwugRasxOCakx6O9Yel3k+ka1Z70kD2e17ZaTEaoKb1CCpZSHu79179txXG57OLe/hg4/3+FYFS2FTeV8MUaqsk73vc1WTx8ISZS/DpoQPxWiy/Y6n7SMZq3rLjWWZ7/hOBsI4GHUj6/ilrYTSJqQvZYmTW9fjZyYxZ5NRGaVeS8gRj2kQY0LwWVpKlkV/XKp7giZYAmp5UzoXHXtuD+0l7wmKTtIyVUvhcvF6Kv/c993CaAlbcxunhq/GkDdZkh8FWJgzKlaQrnp0iadPiCYShInrlCCusho5bcdMqUqDG2utT9cMJFGHNo5/w7xq21tK3JRWiBjArasQGREv0OVaYfCvawfcS3IR57RIxVn0ky7NYN6wiibijZ6HdVhKxQp3X0qSGilz7+cHRFx+1Kz9IoHU9me5HHPvAq3SADdES8XwlW4pTVE19lKaIu6v7NxOIgwthhe2hKfT7bHdR/y9+oEW0fazA8oP0hkBVK0sfE89pRjXmR9XDObmL/UJUSnbCWCe7y1rYhUB+LWX3RAK1cEITOhexbHr4gFhjg9fUm4ylGDpyi4dHpW4rXvShv9oFaHg6gSLuQda62qjn0TpGl0bF/jYUj/EJR/KZTL6H+STGpH5CPJDYnv3I3hy+kmJXnVpZA5NO5RkTwxsoLRqXRB6IoZjXXi+PHq4DcU8lk/gAkprnNJJcqmyZqgRxS+xLB4iif5/ndkegHF473NbocQk+LkuLqJSWIxgWjvgiYE+wOMCkqmWtadrTGdUcjcc+IbJo6+gfEmi/l3UItgnYs5KWNKt2hKUshR0u1z7D3YXvn33dLziXJfrPS37Vgah3SsR39Dj7vY9Cq/l2FXFEWY2VzqVCaBk6jK7rlCXLqttWPWzBnvqyn/YSadzic+ssgV+6jpjefsVxvQvWNX8sIrCzpHwhZu330XUV4IEEwnfBqq6hlFUgJsciJtAh0WIQnUcBnQdxu655PREewJpHQcRjt04uEWXPsMJwFei+Qq2CeksTaaIxCj2S1I+2rsXbiihyRIMurAvDtJl6voNUHGDVop0PnT0rgehz6X5XI9y5rfYSVUfmHqJ+9vupR5ySrEEhYhpN4ThzNiIjhDnVXteW0OjHW2GIR+hltWNcmI85LG34BaDn5mXmPVb9PvrnOtC6hNSzfU/6hHgkd3JH4bmLG+Qu5+kcy8JzzGsQqTScb4U5vSXrI9GilotX7Z8QaPFL5fQ/j04sR+SCH9yHFr8au2C09rvshMCVaHkzgdji4JyFZSmTnt4LwGLW4ocIDNcCPVexNguFHBYfR78xgjCDYRnKagfu5EQdBBpihGKNFt5biRnj+HyMZMwridjf1z6UJXkWgegT24h9BdMELxWYwvkle6IKIi6EQDSNJamAVV6JQK9YaGb3vCIttvyzCHTNDEk4HJ2IGC29t6bByX0psb84VvqshKeyBoFwu2S6P5JBVx0oWuP7uIW8eoGQXWoojY6I80j2GH5JQjo0N41efmFnEZ1B2yL2NFqiB9pBdzZCvkMU1Y4zbCpx1nNsWy/+8sw70qJo/8CFhHcQiGfGxB7FGmZ9Xp1If4X5Tz9rjAiBhe7F7KtssYbsXW68yOPn+25q2T2IhdP+XxLohWwhhiZ9dS4MzNl3ssP6VXvyK+QT1htestOEGeVTYd9AIIyxOqIbPn4j44iGfcXzwA+YPe5tcEj2rDkQjSZokOwdw/SueFb3YE1dR2sO21RVontGfvxO0hr+fLqJT5jXyDJAFKLoGZ5hDyYQ2sreVCYliNtzLDF9Ox7W0Hp8d+2RoSZ6nFxgSS2gttNpPtaTekOgRaywaJr2nEvHC1pRhZyviTqt5ywM3Bl6zsjouftqVtjpBcx8dv4hR+NhbpZbAmF1rSfWRT4HY8+h7hIFQlefO4UgSPcUgGhflXu+uwDkex41aBi92j9Sgbz1A0ExwF0aUbAnmr0w7scopxkd73Z+KTRH3ECPvI1/TyAZ1z1hZpeAlxyBkrNKhFj71W2fJGL158wljgjO/PoJ+0szphYmO+zM6GOj8WNWGBFI1jYRe8FxajiDF6yDR0yg2Kcv0cUgAsF1yDldb9SBoAfQhGtBoJqhwpHVOM3KDxrx6GHecv6NxK/4RLmKqAV9HPpFCzivcT2rTsT39wgU4BRUscS8sxwrffTMFMma31MIRLpMP/nISz4XmBQwtDi3bZHzizgNixG5RxsnZIVGEgABI7ReY3qjZxGIpgc8p9Q0TJQKetBe0AJbh/P1RIukm8TUy+oP27Fobc15bFG9PF4H6jlWafLZVfjGCE6LGnYZckXQt9B3CYp0jWFsRNCjW06tw5jsxRJmzTp6AoHYsIGS0EdMIB8rkMXjCNNGJjE7LzC6+88ikORkS4Qsx4UsvLYpDr6UV41ldmeJ+IF4fXaUqDD4SzPR8mL2UPfLvyMQUWXHgag3K+QvXgdi6xc5ELwWRvf6foInmkZo9C4daNrX+6qBcr1ITiazgzNzexBKciJpVtbwlaxBJ2sEJOKmZI2xIrIglhwJZdQYKFc8AifO/e5rUc/2a5gJA6mfZJ3xkR6Wu9x48a5E8PPs2SfV73tv8UUtn0vN96hJ6DuJ7tMjXZZPTTIzZTV5/yQ/EK/Gr7YtGMm0ZH2MKNkzpJF3WSFtFnqPZKGjg7nuQM+9D1/eE6ywalktaKIRtwk/e+TFohdbXFDq4J4VNVjtEes+6FKo8IBqxetT/eOqkNwSKOJ5OVLLxPrC3XCBI2gHjShOOac/jceWUzQ+wxPN9gJHd7Q1e4OINRzRgoj3pSwrZH5D62kxmxHFEuG4FvjEStALHY91T65hASJV/1IH4lBZWWpYswbaF1nB3u0XHx1IhGo5u7tPT5g79dsJhPvuHpMTU3C/+h7pUX2tDcBLCfQ3MMPjnV3d4pmP8OaLv1+iMeCYuEYnRXwzp3slH4jpX9fLsubcTfhYtt72TyHQnjQ0PrGq94UD2McTSd4x84amxoToUwb3Gnexl0oPvdhikjn7NAIB/FwjhTq+58z8CcsffpD1olnS3aCFy24vjZaM/giVBZgIey5g8HgrjC1uWfjsfawN6MIeamG5aL1ef8ZdBdYjEAQGcXUOTLEWPqH+4QRCJ0q+2r4X62skAp3qCLm0WGeFc4IjKj9hMf6GQH2EeJaaYxkQwsIRFWR9Id58oe6psebN1g3HrC0XP9C4y6Bx7KEZ9RL3JRUA/hmBsIDXctB7y5HvaCdcbqkPpYtE8WzZnCArjIdltLxHB1qkLgQUrVbA0EuYOKyziOPy2ZOCiCMYJXAh7/lZ1K/h1aX9bTTkJ8v9Wpi4+eI9W1I01dmilMXCvayE1XCIX+ubSC4yiFtzijcSHtnz0e/3z4hI5OoLCYFkvxN7OsECmNRQrKWeUeQVCsxmXk+SlEtS4nA+iM6oKr457h9OIOi5e7/GjghNRssEO3rPdJ98VR6oYvA4S5RIJCMXijTH1+Wejk9YjYeTaUREK690R9VJcnm5yEk1rrOG7LM6etxa3EeiBnyyACKk8tinccu6V8uA5mzLMT5xQjevhSEKlSNFRqS4rJnJI7v1P9qej+TGw+mIyICk5OVhlGjAvK/kcVSXHDvLg7KqMkQFfohAZMvhtgG3ax/thUHT1DdrpnEtJIraiNUe0sKh1opbkpG0UQKlvBKy66e+5bJGfL+Gqcq6AzQ70t/h95Xcag4/gK1Ws85UE4HoQ8qKFZNHTvBXBML6EqL6kjIRzznP6YhrpqFVYsmyX0Vm+MRLlguXEeoxPphA/dMIxNFIp5JpuC8RsNBPEzIHIlk9xTOL+NyoP8Xaqep6z2sUTyUQV4lZP53nBcLmqnWOcJgfZtAnlL2+9abUNeJ+OIFk5AB8Lu3EYe/wuVZSgEV+c4kTaTUfIOckr/3NiXzMClt8pftIlpIxT3C9ecUBU6WvOOFECjykXgd6ux+IP3u35iCllQRUJEnpI8v47rf4IIVK6kLspC7ELq8lQuF0aeuyNQJBk8VqvK9kwWkXSNJYfHxkwkHRNPfLXTyOUmYiRfQvFHgEZPgEemRd1v0zKpSJ3RrtEWeYse8755a0tU+uyrwnEo2XOBK2vHd0X5eL1daXOMDq0QSSKFGOTRWrgL8qr3zbxKtK/bfGpUElbytE4vARbGVI25YHFqO9y9xeeG3wUqymFiRG0SWrG6p6HX3GEL22s+cZK0sbqBOT+BQNZH1ys3qOiZZTimSKc3hFLeqkFNXjqOm/OI0P6UAMeKnBifQwal/bLKRS1lHLATs1J+WtBMrSDxIIeac7UVx59a9iDNWcP94yiDnun+YrVjehH7INCN0QsXObJRAmLmJW6p6z4mNUtMAaLYc0lBzZt5M03FwyQnOe6t7vL9Et7BFEQMnSP6s6RwKjVwiEfLU49VUusjUzVnQ53yycx7LG20ndE1y0kfThJxKoWssiJNJDGWftjJy1c+kuztzh+ieSg4PI8xPrQM8hkPfutNHtXxIYcgltuxaYWPafRaCIdQeuVNQuXLeNVVgwZy1oy3Gxl+qHnjusZ7TRGlG1Jtj3/5RAE/tgEDsjuOBvJ6MbhY/ZigAqfWobB268ywpjlyYNJTJB82u2xI7r98gdLysTv6KZw3vPnjLMWwzAVkI7qyXaTk3zVwTaJbyKh6wwoLVEtCxWTaDwJCVn3WJNEX7MJJOckcSXIZEM0YrDMFCI9jE1HH9FoAqRnzvv0UMOnYSJiKtPPJG7HXsvfXm3tpZA+awEeUBWFA16ZLzLTwTiC57Jhc+5bevdCjrQuMs5bwzRyPWO83BSDJVWlnJ311pij14Lu9F+5H4tJQyuNcDESIw+ISTxpp29j0OJrukhPXv6ZCmE/uijuwk7LRKzsi5ELr5mRxR9vEbDBwm0fjua3/NJTLKoUPMaeF97d85+f1nFeT+BMom7zpL7uhDVfV0IvvNlq08M400MlGTDBIqRgdHXXHNVEstPR47fF+MANdb62GeKeQJdanVwbPya4iRJR08iEAYb+4FIoVyrfHGdSazKUtupjbt+rY6SomjB7lopo/UEqp8QkbgSKOfAm7Vncg6i8wTiypNrXJqvPHDqfbBLGz+VQDcl0a+5Z9ctIcV9sTrW/rUKdK+rRTd+lVpUHJT/vmBzPYOa9SV4ASWJgEPSJr+uHC1/k2P7MQKtfifm4OS9btNqaU2yYMyFREDR/bK/uS38aZre6EAt+98zLkCFuB7qmtbXiJDCMGXK01fyy1vU40iS417WB9t6Q9u63BEIVgPNnTJi/SHnGZL20IEQN7LjaDC2HPy8H+tKdKC2KiXrG7cjOA+B2QeO4HtPNBwEyEyFmg67Ba6VdtXEoANFpANhFVf2qxArTMp0QJ/Hmii1v+8frgPJ+PC58QQa1BHAoEilCi98ZIjXjbmOVOkrdnC9TD4b6ULQMXpgDbr7nQA9bhAtfolv9xH4C8cTTFN9o4Z8mh/ImyaS/DNJS3pxoyNUUhZjSRmSZvbXHVJwmOhBHJr+r6u0+oiUtauF6RyRyjz05awxTKb9Wm3jIwSSwZLKzjztCUvRrdSFkPjx9KJz447XIwo7SU/7NUJhqwQS30Q9Lq04MDBbUdELa5qJFAMTK2zvCZS0nsPJkrcZl2Kb+pbTeUjjjJ5FoMXrQCjE4B3Pa7XTnKtO+l5vF8R+wWrcyfRHpYxl530t9f55BJLaHAyUJM18BTvkOHEeKLetlVos/Vp5AM5DdhatfqAnECi6Kwq9RDeqEb/EqSwXw+fTCBStNUL6y+PVWS6Bm4vEvV8MmNpn8kbXGjqrTvePPdGvB+5P+4/fNOc9+3j4wgF4C2obtH2CQhspKgSJ95Vroe9Zy0856IiGUh+Nvi6E1E5P1wiFS9s+HT+yY+HN31LZcZHi1nSS4sEdfTWOqvXeF8TAk3ondk/TX4tB+iodOdafHxmRyKMJBIp6jjuufUtOla8a0pb5TVWOdSGPFyxzXxvRR4jUibfGHhnyKzsW8i5lk7f/MlxgufBL5pvi27YsvkN9Ff1TtEavyP4EaNtDIhJ5/jn3jvmxvP79jwbi79oZ3XrNb9v0pv3f/7I9WyKQu/QD7CmkUpBWUCGLgQUO5gTZkgnnLcjufVNPtkm+y/d9LduzcBU8Xm/YCIHQDHt73esqaRNkbdcSIlJJfT8faOEjLHzNP1+WsJb6F4nshrNuQ1PvHxyRiG6lIcrpuVzPhAM/uDWIhGy57AZbxmu5xGTdfhEXBW1GrDasML+DTv1AP9Xi7LqUjWpJ/AWljwBL/G48MATLTPpPTDBYvPw32pJI3RCJbKmrhy2GRcu75sfnEOj37fwcAvn2/C2B/qsF72sdciIReNtLtVeOu0NWPIfdYmUNJSJrZGBEPuuab2CtxAU1PaqiV+vCZ99Hy7KN1XhcpfPNrs09e/YwQ8DZqd+TLY2oRPo9Rb5GEbv4e95yD32SIIWJyzlwxShOwU24BvyD0+OpX5lAYm0jdw37tFVc/QJ7EbJhwfVgpp6DkDlDhk+q5sXdHvqraPZSg/ixs+daVb3i77t6WTwp4SFfF17b/cTjqRdPB/pbyh5wXliEM3tERKfMQ3d+z/GfNQ7f2s5H0OWt7dnOvvF0i7uslnHkPCKe+7UbsLDWX/ZaXm5iu7zqs6Ce1jXM4p+Hu/9HV/cX9Y5nOZ8QAqb2NeYAJ31i7RslL/prfg1HM0wSI4aEsQQFeq41Q0QJ6h8XD+S7E031t0JZyII6QV0Pp14lrUHtE0RqS+7V3ZZRlzXPGpHHy2OvA82e/ladjphznKcKAr1U0HpKNtQktqVHUA5qvvV+aURcGBPXSVg4P+9RbbNu+RKytXZa95Hc+P/m4+tX3rxjoVcUoosndK1fsS4mcNz/WlgKnu9pDUXy1cRqqcK7uvq3QiCcWvSqT2qfTAWWYPVwH8n+8bVUAeMynrwYAVOLi4esO2F7MuFkUZXrof4q8QPdrHZyC6NlrV0OPajC2giyrThHnhvDKTDIGel5u+brDk5R9MgdFdGLl7pinEPMOqMvjrm6xNAQVHXpa6kvINVZJqT19FKVwu81LJVboof0XO3O26fPb9sZfWZ7tqMDRdauy4MSQlRznXOmXd9fRsxqxiy3NQ4x1ieuPhU9tvTdgxy8dq5fq58cggGfb4QaJlwhqOfk2mm/LkyBS9HC+wDUkvu2ziZhUd/vH10icYnm2StD6ypIz1WKKuTFCuFr1NvpOYeWazIwfxgC+7UCqORqXffte4yJONvoen15ORa5aSjmxNqYrOzUDB15ZrrZmqJHTSGu2nHJ+X3MUpR4zGb7BfizqXau7Xk7gVZxHxK8T979u8+lplhn8fEFH2O1dUVh3fHonLV41lrtiqPTjp93Vhl8clEopa1SzmmLo+1P3/y5Yi1rmvbaf9YphVY713VorYVwW/FA8dlaPeBv7g06sug6rfEup0nsU87P8f9315e+j34KNEc7RT+WGuA6eqJzuA5OG2k9XZmzu56DtniTXLeH9SPaxp/tfKMcBkihfFsVmuXkb2oOvejbSF2GH26dlp6WxsnxD2gYfejH58e/G4jSTv7Onxrxy2c/ONM/1m+fTyBqkTv7cczT1vIMMJh1dh0+7siDh4cfUcdeCdThMM282haB+Kxfj1B1RKuJQJgjflbRqWjt5y0/o/zkItIygQyTl4+xfno/8vzQ/2d87aXrrBBI6K/WL+RXeHYbaS1fHn0ZwDzZ6V1WrtIDp5C/MzGACo/IYm0veusCcn1t6UogHjUMoJVB3MbiIf3mzu4LEIjbuSEC3fXb2wkUJEiQ2zvK+c2z8vWcX98q9xr6l3V5T9fPJtZnSSBQkCCBQIFAQYJ8aQL93h7jV863x1wI9B/gCQQKEiRIIFAgUJAgWyXQ+QM+2yt7rHV/QtA5EChIkCCBQIFAQYJs2wpbg6Nu7bHz+R+udgcCBQkSCBQIFAgUJMi/IpBRRrNwxLuS4Gt3ta4M/3UJmPTv1GKHIbIfcedj65TjT7hxTReBQEGCBPmTDmS4+lmlJbZnADj0TXi2hJHjuWYN2HZjTEc0HNFtslE7Paaz+IYaebO1xRVAgUBBggS5I9CFL8opQwqM60cNbQb6UKl9SpGhX1ryRYxFbp8W1ciacaw08QZPqmws+Te92yg6AofyYU0gUJAgQf6DQN4IG1vrltipNB3jVGOjNavbE2k6rWtii103R6c1/aqJQMiCbLP2ZIk5KLXHmyLTRzRxrdUhro1BuVmtgx8oSJAgfyCQRc0DMyalzlKt0rgkqoyTG1NdjYSeE/3SaaZtWuo4Iwg1zpK1ZfKy3JHGk8VaVwdYYfQO1dMnZCc6qKUf7eZAoCBBgryBQIr9QDkRiBiiTq0rKkJLXLfpqNtWE47IrqpiMs7GehDHkcazamy9FUYEylQTazPWOqH36nGBDjQHAgUJEuQPVpiBH2ieT+0hPRGB6A/oMHpM0vKUpC2bX6n2m3hwpSjSinQ7MoGsPcCD5MZEHfLkQO8r5UDrhqADBQkS5L8JJDpQS7RoTyolPUjlrXbQY1piTJnHvE5fxmWy06V3RRvZWqik91ltFawwQ1aYanMy5XQyckE6q4MV9nOPS60nu9bSs5dqVtdn1se/yLs7/75Hv3sE1rU/1CbP73X03La1DreF1vgsU4x4NZJOo/NUpyn91caWTCzXlHFqbUz6TVqCQOwHqnvh0eysTjM6tNRJWcdEJlKHnIvHksgTk2a0VHdFMf++vXb9HzIrtdb64wgkheJ4Vup08m+uM6eLY1HwspzHYVEU3TrfEUyw1ox7QMW3QKBAoECgDxCICwwriQeCv/lknbYn+IRmB84YMsIU9kxMNBtjcQEC5bmbSdfJtcO+ihaLZ2CWdumI2pN8YP3Q1XhUu6TWDhIaaT138Afil1SnLX2/E88Tq19cWpIAc8Sa3OxQPNnNBCC7VktGkBMBih43/4RAt5S5Mud1Vt1tlaXXBHqVzffL8XU+BwIFAr2BQG5brXHGMi5kPiC2xw3uUtzaasO/ERxUHGk+F5i7GiWtrdS2dj6Cccb/9DZ9ff5B54vatPQfs20krrhGo6L2JebR+phsbx/GLZfbZfJYdmBV8pirqdlLHdzBlVLBPBAoECgQ6BMJ5NxwJQYm5To7DLFGwhIvBJodzyAtFg/bO5rDpu2lxLW9RC4+lECkq8FaPO1Zi3FSlN1/q4EOhHrkMBhLfbMBwYxFvCpuhECOd4pgvci3HQRq/pkV9jD5HYG2OwMeM2ZXIm+zdVvu/y0TyHDaRaNQA583GeF7sVIdaTm8iwKpG8eOVCHlI53pOGvwBmNWgPHdfG7cPJ/dzJHUN4vx7iEtRjiS5h1QbBvHO6uznMxHxGOz2mMUs8XEpZOnEseJIUlMGtsYNYh1GiuTnsa4LTO8hZo5Ql8qXCBQIFAg0Ge1xvLEFd9K0a2+WewkhNeIQLpjJmm2xozfcMj6hLECts5V2yHo2Hn9VPtATzRy1QxCs8koNPCAZ6nNY+OynWbVCGtx7Jk2MelzOs9JGeqZi0lMfxN0mECtyuPa0WuVTXaNHXNi1fQPPdGvqw2cP1R/4PwrAt1bYt+TP9ul670FtlUCWbstAp3X9XjGit85iP0npO0U3u7uJNv9eIRvZ1h3G4Irl95xLJwqjnZNp7de66Hf860K9PeeaChinWuguZC5hUjI5GTztHPl2MxxhadUx36eJq4tEeZ41NmJ2YrIgiQmMpVIPzEZ1vvS3BVJXDSIsswzbQOBAoECgT6HQMXFYyO1OdhwYRf06vkrGEE0o5lRynp/Kb8Dey0Wxeobuq/q8UhPNAcNkP2nAZPW8drdOGQ5aTgjcUlbEEgxTQ9khTkiUFGCQNp7orUiHcioMSErjA5Ls4LIVAyxXwR8HoFkz8ozKgXIJnbuElZw31OXmkx2vTNY8XeJz+3irvPb7v10RXmzwvlamPLboAe7RNIvdd50tMEVQDLLt9c+2AiKNQu7ISuMaaMcJ5/Gib55FhoPVrXQXgzvI1lhM++hCA8uu5o16UBHZYrC3Mbq/LL2/d+2l+eg7Alkd5keERzgiiwvCiYQ8kVa7AFKJhoRSFsQSOfsnIYOhPNohEAqTWke57nTqw5kn7waby8dXjDeC3GijynblgX20fTKJcdGzEYQwjtTAilC9uYWWcbq199y3frymxHIzvyvwtrBlyAQ+yKKrbVvXiNYvCdtU14p5SqO9xkt+5WH4rJrtHAIt3CaDaXfR1qDQByWY0gHws+vtJ7HEkgiA5rxWAyG2oqMWH0q8rwrkhzeHV3CD4T0NVhbZIXlp6JECgm1qYoRIKBUnCg6TwUdCFRyeTzQJ2jdtM8kkN/93LoGPUocMWebjdSzY+o9/vSUXndAR1UUa40F5bXGq/hXrssMwxeeeDoqS3+6ogaaYfrtIhJ58J351Hws55nn0GatRGrqqdimDoReLIqtEYgdymNKd1sa+ai2MWJBm35nxyM0o5MjW2coY9fs8jje0VN5aU3JKlO5o+N4WannG7h9Wn1WzMXOWba+EEHYcswPaTKuHGFzxaNYYdTPE4Ih17UwxBwm8fGIKVzRyWAtLIUSktJ57Mi+Gbk02xPXwhybERzVbY9OnPbJWFpvAxeMFqvtdVNzK/t1k85ZHMF5tsIQzM06qZMzyV9/j3HpeHa4EN9uLWw+n8azwrqCV/G2TKATdPK+2CKBTmNBvbhNAnEEs7NqId0i3ZUlcUfH+wLGTuqyXUFzvHZxbk2ca9JBrI0zXcVEqpH9K6Vuf2eEPZBArJiV0CSOHJlNs9NYV2qOAvI1ZmHpDrxux0cguKDQJSIK4ENySnxZPMvZhrP4RGefuhoPn83cMhFnDVzXUlAptfCgmzhy8FQNsibJ5nCr2xEx6e5sMpRmYt9VhHQ7BA9ACWp/1oFcXJ8tjf/vRiDqvjmezgqnZq8r8hslkKWJckZTt9c+E0/HQ3o6KrZatmSFGYIK0Ydm6CElwIAo1I3lbn9EJpjVQqCiiJPO5q0hm6eL6JgyT0hXsgYBf+Vrv/OjOcTagtLuklRlJUrJxxcXXtYVvfVrGUJgllo97t4dgzyUURf+yadaYfxvk2qCT+NgPtZ1tqN+HVvXkg6XpezHgtccwZx56vTY2nZEn9tzRh3dpvzqMpKpiRJNUPHan3Qg0v2is+3j4psRCE7oJm4aUs8vdv6GCUSwtOeervTm2kcTdSpUNm6OQJjTII5TVitkgRlPoLxnK6y12Q52TtcRgeDJVWPqJl5DIgLVRKyM7+C3jqBnEGjVXKzzJWDBFHtlyIVAnCBSrO4sV7BHi86u0z56eo2E9n4Wjq98pg4EA/V8xiJe4wgh9kja14AgblvuBkt6Zpoj9XcAWtHzSPLNYFvutMkzItCocyJQNZblDkppijoGP+lASsV2du23IxAhiAg0n1UaI8jDbptAlmDpHDV1c+2z7gAdKIs3Q6CbpUOL+kCdgg50Qp1VItA0q3F/1KhLRrOh4SzVOEHlDvrJDFkEUqVjf2SdA74V70s9n3+lC/29P1Io4yOtkRykr3lT8EHz2JzVutaN/DTdyEr2Ed63jvSgYV0rhedX4xMbMOjJeWFcgIAjmSbYtfZ4JAKxpqPHGpEEJ+Y5x3iitiQIlIxkX9LjHYcdlCkTyFdeSukc2tNP3zLFC5Fp/G4Ecufm3MSTIx3ormrAZglUW7oPdNtrnz7QbDWkA5lNEYj5A85gLft0eIlLlY6sA5mxL+iGTTZWRRpOHvNaEmKKD2NGj1N3rlsm0MsiforCPZNAq57jZGVaCOSrcyBigFNhfdKIX1bSWqpddAX7/y+5oBKSw9nyvLqP5afHE+j27BEdsBBRpiLPoHklO/pK0oFsmy70b9qyh1kb1ka13kEH0mQbw1TDOh7pPRrlcnXsZD1SJ7nkqd40HPq/O43n7yZ0iiAQnCtM840LbOEtXgWaG9SL3WmUWD77+QRa7yZnnp98i160ZccnbAFrTi0vPVUW3tOWKBQnNG0yWGFEK9ycDdYnOE55/GMUrwI9bvO8P+CJ5n08sG5kJYrJkc7mVg4BOIqLbxyLT7gD/SeBhCwgUBaXej8liA9AfUkdj5XlFBF9Ik1yJLOrxe0AlW5tGhvdxqUtU4uqJ+NI78HFAZQQ2L16udeJSuPexu23IxCiL+nU5ng520esGTxZTqM9x/28vW6ceZlCFkvtdvxARCAHAmFuG8TTGLZn4Gox1vpah1oqWMCq4T15LB9tNAdIF6409/ti/Fr+jkASjyh1jGopN2bdIATya/AlCMSZahsh0K2rTadxvCMC4Xd8xJJWeWoNdBbsboTFsXR26Qh3YTwiUugE6ltrOOxA415Ar2oOBq9L3p2kxzL1rVLQIBLl/B3F8vmfmy/RVlwFe7abI5ByyocqbaZE2WpRS4yS5iwLGvNsmbiiQ2a81HBFRR2JyOnIpiGj5ng8FmtGvDpw7O6fVCAl2fYfJRAHxMBfhdz3lOuQ6YJ0oJR3KQMTEd0se7/CYb0tAvGGs+z5Rvv4XyxBwg1OjzhECFuLmMEB5vDKGTa+4K7iYkschehrLmm2MDly8Tb/iPVq+x3p0+As55kAZN0XOEO7TWPRp5RvqkiikAFxuepQsCcCtQb9CrcjAvH+p52SjFWseROTtCfQcS1YCJ3ozwQyf0kgXykNBOKVO7ugUtmB61rDfmTtCDHPMfZydWY7BOIsLykUawfniyr5ZTk9c8S5vcSmcw8Zjpb242V2V+zIx3gv1ysjjB/a83z+hmJ5NRERr1/g/HC55/O0uXY1zi8lztuqzsGFTt3h5cc75MUYdVDvfM/hdb2/d7ZXk9alMTe5JPWQxLPLc+R4lXFfIGIbVlgSl7ZNkc+5JR3IulVxkUU467PrrrckIKaQPN/1TjV7zQgrBVIB+8bS1eI8b+yd1jN/BUft+/EzA0FW/EFfwm/FmbTbs8KcuhuR2yEQJHsPTH5k2GBevfM9L9Cr/sIK8wRqYczkqdtlbkiIQKehipui3PVEIOvIKOOcVLcxAtnbwggz/1yUnPO81rWaL/FZWKWThLIZQ3kGa5yvxI/0MCnzbc93a2EN60H2ezJoNTK/AIXQSLu9e4Efd9uskaiIENnL23WaTM2u+fEjfXl5B4aU7FH/F1aYZgI56ECNlOcw+clvY9ZPu5JX8kiQOr4pP9DKoPuSHFxCya4z6xIb4SMs+XnnHTxWLBHGzuVz2Ad0q+2BTN/QBms8iAHc+UsQdpPeKrF3/CjaEoGUJ9CB5M0Mgi4DEKl32GLK3eqB729vt+pApOVMDttM098pNpfWyAqZkRGPaJsSueR6WwS632fn93VX31Op7BwkyId0jvN5izrQj5cXYdC9VvPyW5pYfs8LQSh6O7XcXxCIY5/hidYoupFB5UlRacNgl/qq7+IEFlipdQZ7LRAoSJAvRaAMdtitGvTC/uPrXy/3BNLevXNQ6heYyh5NINkRyMcDYWU749r06cmXqUfOZ7wgmibOi434gX513X+fu3u/R08gUJBnzPj7R9sgUMEEAnyIQRcEkVVmDvSPoucMPVlao+gv/6rqQKCXQxPhPTq6BQ7sOf60V1adcn+nA/HsNHp1pSC6BjlpAyqm4bHVBdeftPp4LGwgUJAgX4NAbiUQEQNa0AqS7AX0STMFlmTGZCCSZ0rXKS0r7PTMizPZ3br7C72PVKpXLqKHEEitFZMls53355npoT3y/sfKYL0I4ZJbI9CvifPztVgr2P0XdwKBgnycQJtaCztfdSD4gQwUl1XNMaYyCUhisvzl5QdBiP41Rl70lhtz6yUz93YYnEl0OFD0SALx/olKytXbgpQwoo5SQ+ErcHcIEzaK93t11gQCBQnypQgENxBpOZmnSUb4MRn9n5kqgaIjBCrvCcSuI1KWDnc6EMEnE5vu5YEE6jrrLRS/tbQtirv6HFp0JK2V20o80Hu24Dn7amvK193+FdHufdZBgnxdAt3sYu51oAO0oCSF9rKqNxmpPj/EnwMIvVw80yi5wx4fWGg9KUHZ/foZuPSzH6goPl7hDt+Ifc2Komg0ohPp02aOIqa/Omc71E/ssMcrtCU1BwIFCfKVCMS+4xdTpf8ZFZSmK4GKAu8h5YfemL78HCCdptlPK/h/QyAnBMLslNqGllPtFdf/6Vb/bdchTqCzW9CBggQJ8icirv7dH7IKRloQYnz+GNqTcllEWbzPWE3643vynHBxk8H67To0EChIkI8R6Mw5Xu9IyhACZZm8h37/+HNyRp4GAgUJEuQVgc6SL/ryvjTTF2MO70uNJyWLi3wEAgUJEuQnAr230oYhBL287z1c6KxwgUBBggQRAq2RJ0gwLdb9O38TvXJzLIEENRKLQt3W4PpjhTLjXCBQkCBBfkUgdV/V+Oz+g0CoBX+UXSsUH4namX+u0hoIFCRIkFdW2C0i7jYb/Q9t5hIUeAXXW3OZXCBQkCBBbglknfsJPOr3+ZLW1znCQRcCKfMWAln7f0kg92T5V9/zz+WLnNe/vt7ftBs3f323Ot62QKDve+nfGVb+ic381R8bad82m/UVx+J2b3vBCnuaph6a+l2b9pnT9z1W2NZ677ftCQR6Rm8HWH7bbvwyBPoqFzPaXk9/ccX3Kyro273e56/eJPVKrvVs/rxb4V8bPFszwH5F0KAD/d+rQaED36k0vgtG9qEE+oYX+lPXwr6x/89+lZZu9TLYrSpm6jGfol6FMz5BU7NbWu9Z2/N2As1PFssyfzuxX+XE7J2EjnyjGPqB+jLP6k3HD8P10WCtng1kVh0JfZp56/fi6Hd1n/Sh28zl9O3ZDoFm0hPWhn0vBM3YqPErtBP/40LbTV4G7kW7zY6bnWMO3dEBdJlnTYJ/UYNwPUBoI1IUl4d0pDG6sc40F76ZxzUTl9Wdt9Nt0p5AoECgQKAtEci5BkPGBgIFAgUCBQK9h0BEE8aI2GPwLBfvtpXmuXFNY5vnzfhAoECgQKBAoP+emU/xdgUCBQIFAn1zAsFqEnp0XSEI4sfGHI/G/JlGeJcjDahxRSBQIFAgUCDQJxDINs42Q9MEAgUCBQIFAr21434m0MD+Z3iSQR5QSPzKoJIW97SXm4f02LrauAEfCt+1vHr1cQcCBQIFAgUCPZNAczOmZInNgUCBQIFAgUDvsMKK2RpjxpikKo3RtumKoSvmhlSawWJd3jijzWBtgx2Roe3Qexs7xrWjN9ITpcpGbfSY2qakI9xU4jCnG2uHIhAoECgQKBDozwTKtU6JI4q4AQI1TruysSXNN20aC+yQnsRKkG1mN9loHFuj6HgikMlGsEvT7KRfk9MlhwhZ1zQuECgQKBAoEOg3ABIrjAnUDk0UD4c0HeOszOP4pMssbfTYuio2mhSkkbhCv1pQhbSbNk1ORBnTQneCAkU60BRnxKN4kQOdttZNgUCBQIFAgUB/JlBKUDkN6hQnhJ68LMdTmYxNGZ+aZDRpZtxJ6zglvtAMJAiVY5XEpVFZXJZVlZEGpcfMpanW2cnKgY2d7Bx0oECgQKBAoF+JuhBoXv1AuT6kJ63UmM5zEhNxkiQdSRXSIxSgsorJuhrbxjXGVCMelgf6IYOLjmqaMRuikdDV2iSuNP0enH3cjA8ECgQKBPrOBMpKQIMJNBFl5jIGTMjUSnLSighPqU5Aqbh3syHmpKVuR1hv3hOtTZ4Ndkyg+7BVFrfazoFAgUCBQIFA/0UgywACSQyZYQciy4F0IG2gA2XpqKucUFRaU8ZVQsaZ1nagN5TMmLhiAummH0s7j2lRZGmW2iHZEZasGWxThLWwQKBAoECgNxAo1Y3xOpBp45IXxxL255B+kxr6TepNpnXUYn0+IYOsLNPUpPSgjfq4nOcxKwo6uhxsGZNtliyDfcSJf1kCrdULf/6INcbqtuqSPC+VCCTSSh4dj9faBHiEGHX8vmE7f4WZvyGBZndjyA/D4YCQfazHog8Cgd5HoGFAhN8wKDUP6MFPb1chg9c1NHpdyX6gVBentIFfhx4jACiemoYwo08wqoaBNZ/J6mZOT3RiwzIORYqnCnp7jXggdxrnxrLVFhu6GJKk0f3N6foZb4FMg2V++hmQiG/xv6KZbFEXROsxxay2BEuio3bWUEOLIyIIigajdhjsfDx2il6b3dC52s1WG5rhZVF0RSBQIFAg0GcQiOcxZm0JE2sYjCNDCzOd5ivPcw46NLC+BrijG4drX2rbDM5UxUCHlq4oEYFIs76ZG5re+Axdo2CZfRiBCGyz0Rbr/PHYNK7jeiCKZi2ijoh6IBD1bS32Ydw21Gh3LKizyx5PJK4YXEEEMnpuyEBk9tIRNMOPXTc9nkBvscLuCeQvzIUtiEiXn9fP3Fm3zs3fVV4TaBYCUT9sqOroFyGQtV2nPIGERhvouNmdi2Z2NJmdJU1hGBp7PA6ADk12UnLOmNsgiaZ5fgRndHFsbGdJH6FZbBQRSBFPJ+gbWjeEHC4TREBwbIG5v89UXXUgwM2SoqVtmdbW6dJysLb2kdqmHFsEQTpnSqzZWUtINcNQkAKUxM1cxYtFC6mZ5eCIS4izJOJy+KQtXCBQIFAg0GcQiHQh5JM2pEsU0AuKY+FQc5UMHSgKNOvJzJnxTFHAujkeCVggC+KC1JGsghI6MRPLWjzvEDttGk1KS/NAPxDYNjdjWUpcdkuqUOlOKdl/Cf1Nf8VkheGQ0jCBBihCxB8hkC3HpY5r58a2yk44FqGU9HxDH5A2bviXBLrWH/iziviaQLe5er+Ypt+aQCDvSqBhCAR6L4GUuvblFggkV5jAcjwWqM3aEIsczY6GjLLCwQbDvbWZO1JpMBCOR1KNbHEku63pXEenpNRQdErbqWMA0bH0EgBlDdI47CNUoHXGk65m4GDaMYKaniiTpjaP6yEZSz3miCVQChPbVnFim3LXNknckg40a/abx62JKyz6mTxuHelEtSUyHfNc67hsXCBQIFAg0CcRqCi6DgXGCsDjSFPD6YbayPyBFeYkDPp4JPMMvlw4YDr6b1ZNMSgyhCbMiQG5Gg1zZ9ZcJ8ja8+MIRJ+ujBEfd6qbsS3LZKzTfLBEoCourRlTQydj55KssMFVce90njtHliVHFsQmihOl6I35yVqd81rf8Qh9iVD2BB3oV55of93Z14wsYHHI0Xyyq2fu55Ehdhe9cvsZ5v+LQLIp1FqhYQ4E+gCBZg2CiwVfFNu5wqTykMLTwN1MNha8OoajeCzpMZg9RBtSbYaCV400tB7VaKsITPCqIJOefs9Gs9U2S6VEmGiW9afHZWW4hlQFot+gdRu3mtfuRuJIUSQjcQm5+a0xQ9EgdCkhLhFdkNlGGtvAoZSJqnfl4TAmJj2RHZxnJRFomthtnQUCBQIFAn3OFe66grQZp3kNKQGJDFGGfUTNXDTeM4qWwxM9qwKeLCy0E3UaZ5qOFKNObAJ4nudGYXUNn41iQfZhnujZFtiqo4ATmbSdMSnL0g1CINJ6ElkLg9FlyMByQxVPR52P1PVuYCtM0/MJWWHJIT8Ns9eBhinmBf7BPodAvGcl0Rpuejdp3XFBk7mB+xsxWLMjGFKPDvDxFwNca4Y7U9sBMQRNAQ9bMRg7ObDdYCg5rAoaccLD0+YhZ8Q5Z78dgWD2z2pWh4H6hG50A4i0nTl0JVAj1dJx13uIA+KxBKJ7M9HnoIqjmYthI+PE8vwAdpK4pX/Hgymx847s1GPcANVoxhoSNJ5Ocw0Oa3h/MA6xQSyNFO2wmPzzE6u0IhvNliMiIeMKQZNleWpAoGxEdTRdwRMN3cuYuKbW81N9Yd2xIH2oMFo1RKCMzpN0oGIGlfJ4GBB5WWXvb887CAR0wC/vqEcnLDPODaexjC09coMbJqUHa4ZmwIejVhyhhd41YAXS8E5IRmPucYkmjG2Xsi3qLIK2bghEmuGp+W4EsrNyasaCwUB9RWb1ZgnkH+EqTK7YGoGcLZH+eToWlvSIrbSNCQQlgGZDaWBlkcUy1q6MaYznlmMQT7alOV7GrotzerHiRSgOzGm1jts4XrCs1JIh45onkNXP+IZYgoRYqGolUZC/s8hz0szGeaZ2cr0iO7i5rMZqsBrJaUlxbBxpSbvp6M8tJR0oTYdi0DjB3TCgEklcFU8hkAivCSKiqmSSG3R0tiPSH0DyUtdOHTTrQFZjvZEOLi0dXBTgu+a4AbKI58ly8AG8/M1o6PzaRpjlCWTr0zgPBN0NTc5HEIirTI3jfIhbVw+KdKBufhWPsAkCOXY96Pk0uibum+0RqDHpeKRePFLvHe2GCIS7chnvsSQ2mD6uTbojNSOdy12rx0zrU5mNDaptNHFOfbtTBtYMEjZg/owDWTekl7QF3aGaJ5zXGg9km647FhN9jUVdItRtbBAhfDS2azTH+SA+GrVGKo5MQpzl8Ujjl2fy3NBRXAOStPlicCVhLCMUEUt1/R67+N0EYg+9ZmRmzUBaWBxHnFQ3tjXc5U28mIQjyznmuZSs3nZsiop0t5KOH2edngq3jNTP0AWIanQqdNNwiL5aCeRc3Fsa/8M3I5C1zk7xMh9G0l0dWaybJRCHrTRxNNvT2G3PCnOGZvnhNDKB3HYINOOmXMbD8XgcBrJQ4C8hskRkx7RznJWl07AZknie2Y9Ctk6emQjUGdsy7ge6Gyd0x27s0DxxvzAhEKLyLW8QjZCfyaEv6aLTb9iGyhPIImKfrcXjEdYhmYsFdBHxtB8OiDjgomslGq21G4rheQRi/41uUlh91mVxaZYo24kfCCUG0vTwQj2enZhAZZ425S4d2rFoQH0UYEpbIpAzEREoP5U6jsg+0wYq6HzVgWxTx1Ezt2RZFt8mTxXjE0uvUxy5QxojG0dht95NEoh/mYl0U9vGxeZ0INSs2B+pF7eiA/kKZRxCSASqB1KBLFkovJZUxkuhx56tsNaiABkdQTxq5l12MGOmekl9IAIVM9/WB1QDulmU6R4VcLBaYXq2qmmgxCAPo+N1utkgC0TiIxtexXMFIroJVro5MpvINpyPx2aenONVO/HHOQQvOuhGBDR62HTPIxDc8ayzISZpIOxo4hD7gdLyEJd2XA5pjoU5OgPSeajniUCkAw2OrEeyM0uygsv0NGjoQHC50zWizyJ4OT1I8pTcTZZ4RqRmwQSy9rsQCBd4IRYfsnEq3KYJhBXkOqYhSdO82xyBaGJPxUqgeTMEwpo5/ECpa46uVtCBmECRK8cFmWA0M+C1SGLbIJ5m16KYUIP7MTJA4/7YIDUsh3d3XQV7BoGwG8eslOOUEWUbWfZHJX3ORWvgL1eqaIhApOcUnaZeRtV8hDIRZhBR3SFzzSKXhFQgjvbWZHoOyOB4phWG6ATSy7hoUm1RBqWYsrF2BzyEJVaplGMLaiFQcST712YjMoGbYidhB+nJmmospURTOlgy6QfeueRKIAMdyKWwwopvQSCfmdrMw1zHC+tAQ6PMZgnEM4p0oKiZ+rjbHIGUwfowcfyIde3trIUVXUfcsEuM5e38AKU/x712avSYFrlG3B8i+nJ6Jk6mbkzVYcy6Ls7Lsk6quC1UleiSY2x+v/b+F+PlSiCiGmkzzk1F09HN0PHykGno0g+N67qh6VRxRNzAoHGksY2ZHSs5ht6nusJoGsIdWEQcU6pBjJObtYGP6Ik6EPQuNlWTeIFnzWD9jixeUocO2amlf9OMUD845LwkpCnDCvMEGnYJrzqSFaYRdrCr6HbhBp2OfjXyhkAmXqw9fTsCsQFBludhpFNzzYYJBEc03HooEVFsjkCzKS9+oGOxETcVEehYuM5i+YWtqgMsKqx4U1vLsUfVDRrWWC/K4qaLk64b2wMRqOlK3JxL1oHw1hEx1L8vy/oAAjWsVyF4zxbIFHEN9mk9nTi532J3j0F1BKCBLB577LD+jpza7jhzNpsi9Bh4fJqZaIW1edkTtkByve2eYoUJhailGgSqiECgUKmzJJGCt7Y08VhZvIAiTKTYaIkiyEjnJKzjWA7a1hnq3+JVGMQZoplK0WLp2p39Wpg6jW6K22/jhvYVyhDz1JzGpolbROg3WyTl1Q+kZmnqhm4AF0809eI8x31jkQq6gfV45Mo6RMgVxVEd7KCagzoY5IwgTYMOUNYqMnws30+t4vQNheRPTHl4WfxacSO7O8/+2FXkOySaVRllkO9h6AveSaNLhTLUhJE6RklJtLNw8qCiGta49KwOMRzNWNfGeTVP7LZ3EmhmAqHm0g71s1MOJxixFpYaTTqLriwXwD1hvySYu/GImrmo0RTrSsPJlvIbUqTljryvGxtjY+Q4ItETCHm7iJ34bgQCgM58auyUtlsnkFyFDbVzzQubm+aEgDFLRsMmjLALgchiUQaRuUodFMFRCCQMUbd6DJ43CI5vhEBDwduCqZVA/yHGMIEOf02gVENFqAc7GEVtTlPdKDJG5gOZOdpOqtSkD3WN2wKB/FqYZf95aSVxd0DBgYZDVOkPO8smbNSNuDH5WkxjCtNROyz48e6PHBnK4cD0FqsRRqotVtngeVsJhLX5xn07Akln0Y3vTChqzvPWCYQaDq7ZUMWUiw5kkc/plYMNDBOFOQ0CqW4oiAwHyMvhTULKDs2Ww7sEec1IOCg+RiCpFljusDdHGTdOs7l4yPNSGUTaGK7jqKAxlHRe5XYIBP7K/o0WAQuDE43YGVLkEGynHYcrYoXPRxlwuUfJ09PMpJoONnzjgtOdYAQscfYdVARPIIfMjWdEpX++FSazh860mb+ADkT3aBS32ZwfiIvqnFHZaxtu6DsCvbykaZpl2Y8fGYv/9Rt5aRRNnZcsSyE/fvz478PlPQesEv81gUZeic7TCbWs09akuTYIWopNH5cwYchsSbvO6i0RCIoOgiY7OMxpJhWoboLySwhfQBYR12GCa31AibXaYfnHYqBABRgcqMUHwQE/sA++KAYM8ebGCoNmKnVUvpkVxlXvIMygjRPIsmtuU+6qS3UO1n44XRMK96cD6EKgeR509uM98vKiTGPe957sRaHOqin+VgcaGiJQW+wyXSY7EAgBlOVuaeDNzTlyaXpmFeGPEQj5uyiFMjVIsGVziQes/GZnKzEFpEFOGJvAlm9XDWe2zuBTMXRFwzYc/w+1wN54omGFuXn6djoQQi3OHFjenJtm3jyBZk4int3WCCSV1S+py3Y7BGoUE+jl5e00yQ7G6R/ves+PbH4QgWypdyeJk8kPRKDM14WOEzvk/PhYlHZLBJolQhDYAWJIT6fxydiZpZhJgR8oOLMHCzMGfxVwZEvBf86PchyCKXFcjZUqlD4S5cw52fYb6kB+0e/MpfKarRMIF9U5O2yNQDw6mOdNs4VojU7ZGcUuZoP9JggQB7pPv7ywHfZnmhzIDONf6hD17dsQdAD3/oZAHccRO8uxAmOGStBdmg7ViGLPHXQgm2Pj+vJYbGMt7BoPNDMbnEJtfTsrMEZUIFewawflUMi0kmomeEx/OCmGy4hCnRTWcTgMk39dWeMJ1EhZiPm7Ecj6ui+uWY2IjRNILtoWCcRKJFcQsXOzHQLNTKAfL6Ux5kBKzR2AXn5DIOplWFZwSs/RGwkEJ938NwSaEUM8NFWcuSHDtkFpdzoNZZwOZdKzFYbAmjKHtrQxHeiZEnYs3ASBwo6F7yWQWGGAIROIjarDYUVORnyB/9h7pn+If/rlos8MxcUndHiFqeyHP/L++QOX1/oogexAAHPTKJnj8yxxMvAD2Ya3MetaesEg9yFtCtUEAgUCBQJ9JQIBPi/ZDYKwgp7hByv0Lz/8mrp/1ZBdgPfgLT8hCJ9EP3jzawLNHyZQ0SCNQk3aSmlAWFuaaw1qzlDrFD22inMViq5RWyDQfZXW4pX85fXrbgg0f0sJBPrWBMLuGB1nmNNYBoEUEaLP6Ne6dkUYIfqk2QFg+mFMejikK2sQYQgCKYVX7d26WMYAIpXp8JLd+4FQA8NHBX2AQNiPUClCDmrG2qFAXikcKqigj1hJjpHpjNHDsVCBQIFAgUBfikBEnIMbCBvq5aLJACX0TEao+dE0hJ901WpmsdxeIqPUS2bsyz2BUkYQ/nkcgQoE9XWowcFVqweHvNLGWXsskBkCApGOBCWIXn/HHqj/jEAP1F9ZAoECgb4ygXh3cnUlEJw2hAzShV6umgz7gVil+UHaz8vLj4sONFsj6/KEqSxRh7toIUJWho96uTPPuD42y7sym/2MH5xqBkucQVgx6UJNx7u3dkjtPxaSbYooPRRLPB6NCgQKBAoE+koEgtWVwXtjPE3g/skyBTMM5hSIcvjxWgciKAFBRt0pO1CaDnjLnX/oLwlUIBWkUyiJMwxzc25QcaNArbL5eJwtE6hAmBN2lt4GgYhB/+GJvjfF/twj2stPLwQCbYJALhDo3QQyQqCi0+zTIZVHTT9edPLnlXVSN7ofP3qF9+iK3veGAOkrgeYP1GWeB7IZLfYy66y2qOdjHbYwNKgZzTl3HLNouiMTyAQCBQIFAn0xApE+o5ofL6b6M01QKurHj0URsTJr0tV0+yOBzMcJRLoaiiQOBXxBCDvFLr44B8O1V6EDEYFgp+njJgj0+12bHyxhNT5YYV+QQNJdXKnekCbzriSvPDsow+95e1bGmB3Mh7hwIdBWui0QKBAoEOiBBGo4FPqdqakcLJS9LzOVqBUIFAgUCBQIdNM2EIjAYKqXzNfaSNPc///qvzznUhz4XWG3CTstGUpzpJe3/fo/Ly/mYwAKBAoECgT65gQCgt5XbEwdm0Grd1YoM7yhYCBQIFAgUCDQrR8Iuywow+Elw+2LPx/fdR1vyFMcsb9qMXSqmc38tixQdgLZORAoECgQKBDolkDWE6hgAklDh19XD0EYHJK7Ct5fFQTqEFoNAv02/mbwwhpQIFAgUCBQINAdgbBtx01ZGftfx/OeyZ5F2gp2bIFiR7/Pw7runMH8KQKBAoECgQKBrgQaeF9jRkTxK3Lc7r3DBELNUChD2K6zofcMMN3u9+l5/b6rFIFAT2iR+1alEa/SYFp/kaqz4tAIvfhOAs33EbvmRn724/ziqAtTnhwByDWTN0Qg3FY2QyAUT/qOBLJfRQeSmxI3dZOXQXQgu0kC2Z8J9Lujb1759wQKOtB/Nojvvs33Q9DrO2TQgT4mslvCVrvtPYd7p/KtUfWYYjd/nmTb2qjOvkcHsk8XscLstxNZKfkCzfRNne02L4Nv2iblPVd4tp42136/EujZDT1vrOPeQSD3bOGveP7X/HO57Hv9NVp73nTTvuH4+L++vOd3ECjIx8St/3+Flv7iYejIPzTr02b4tXrXt5LP04Euffr9bjtnZzd/Xl5Vu/xsrn3Wnd03GR6K5BdP/fTko4fheWPT4vwrLSjoQM+4dbuvogO5y6/tNc99AR3orQT6JZTUx2by/4sOFCRIkCCBQEGCBAkEChIkSJBAoCBBggQCBQkSJEggUJAgQQKBggQJEiQQKEiQIIFAQYIECRIIFCRIkECgIEGCBAkEChIkSCBQkCBBggQCBQkSJBAoSJAggUChC4IECRIIFCRIkECgIEGCBPmH8j8BBgAUfyQ0kYbxigAAAABJRU5ErkJggg==
+
+
[pic1]:data:image/png;base64,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
\ No newline at end of file
diff --git a/springboot系列/消息队列/springboot整合activeMQ（2）.md b/springboot系列/消息队列/springboot整合activeMQ（2）.md
index 61190b0..8e50548 100644
--- a/springboot系列/消息队列/springboot整合activeMQ（2）.md
+++ b/springboot系列/消息队列/springboot整合activeMQ（2）.md
@@ -1,153 +1,153 @@
- 单个MQ节点总是不可靠的，一旦该节点出现故障，MQ服务就不可用了，势必会产生较大的损失。这里记录activeMQ如何开启主从备份，一旦master（主节点故障），slave（从节点）立即提供服务，实现原理是运行多个MQ使用同一个持久化数据源，这里以jdbc数据源为例。同一时间只有一个节点（节点A）能够抢到数据库的表锁，其他节点进入阻塞状态，一旦A发生错误崩溃，其他节点就会重新获取表锁，获取到锁的节点成为master，其他节点为slave，如果节点A重新启动，也将成为slave。
-
- 主从备份解决了单节点故障的问题，但是同一时间提供服务的只有一个master，显然是不能面对数据量的增长，所以需要一种横向拓展的集群方式来解决面临的问题。
-
-### 一、activeMQ设置
-
-#### 1、平台版本说明：
-
-- 平台：windows
-- activeMQ版本：5.9.1，[下载地址](https://www.apache.org/dist/activemq/5.9.1/apache-activemq-5.9.1-bin.zip.asc)
-- jdk版本：1.8
-
-#### 2、下载jdbc依赖
-
- 下载下面三个依赖包，放到activeMQ安装目录下的lib文件夹中。
-
-[mysql驱动](http://central.maven.org/maven2/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar)
-
-[dhcp依赖](http://central.maven.org/maven2/org/apache/commons/commons-dbcp2/2.1.1/commons-dbcp2-2.1.1.jar)
-
-[commons-pool2依赖](http://maven.aliyun.com/nexus/service/local/artifact/maven/redirect?r=jcenter&g=org.apache.commons&a=commons-pool2&v=2.6.0&e=jar)
-
-###二、主从备份
-
-####1、修改jettty
-
- 首先修改conf->jetty.xml，这里是修改activemq的web管理端口，管理界面账号密码默认为admin/admin
-
-```xml
-
-
-
-
-```
-
-####2、修改activemq.xml
-
- 然后修改conf->activemq.xml
-
-- 设置连接方式
-
- 默认是下面五种连接方式都打开，这里我们只要tcp，把其他的都注释掉，然后在这里设置activemq的服务端口，可以看到每种连接方式都对应一个端口。
-
- ```xml
-
-
-
-
-
- ```
-
-
-
-- 设置jdbc数据库
-
- mysql数据库中创建activemq库，在`broker`标签的下面也就是根标签`beans`的下一级创建一个bean节点，内容如下：
-
- ```xml
-
-
-
-
-
-
-
- ```
-
-- 设置数据源
-
- 首先修改broker节点，设置name和persistent(默认为true),也可不做修改，修改后如下：
-
- ```xml
-
- ```
-
- 然后设置持久化方式,使用到我们之前设置的mysql-qs
-
- ```xml
-
-
-
-
- ```
-
-#### 3、启动
-
- 设置完毕后启动activemq（双击bin中的acitveMQ.jar)，启动完成后可以看到如下日志信息：
-
-```verilog
- INFO | Using a separate dataSource for locking: org.apache.commons.dbcp2.BasicDataSource@179ece50
- INFO | Attempting to acquire the exclusive lock to become the Master broker
- INFO | Becoming the master on dataSource: org.apache.commons.dbcp2.BasicDataSource@179ece50
-```
-
- 接着我们修改一下tcp服务端口，改为61617，然后重新启动，日志信息如下：
-
-```verilog
- INFO | Using a separate dataSource for locking: org.apache.commons.dbcp2.BasicDataSource@179ece50
- INFO | Attempting to acquire the exclusive lock to become the Master broker
- INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
- INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
- INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
- INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
-```
-
-可以看到从节点一直在尝试获取表锁成为主节点，这样一旦主节点失效，从节点能够立刻取代主节点提供服务。这样我们便实现了主从备份。
-
-### 三、负载均衡
-
- activemq可以实现多个mq之间进行路由，假设有两个mq，分别为brokerA和brokerB，当一条消息发送到brokerA的队列test中，有一个消费者连上了brokerB，并且想要获取test队列，brokerA中的test队列就会路由到brokerB上。
-
- 开启负载均衡需要设置`networkConnectors`节点，静态路由配置如下：
-
-```xml
-
-
-
-```
-
-brokerA和brokerB都要设置该配置，以连上对方。
-
-### 四、测试
-
-####1、建立mq
-
- 组建两组broker，每组做主从配置。
-
-- brokerA：
- - 主：设置web管理端口8761,设置mq名称`mq`,设置数据库地址为activemq，设置tcp服务端口61616，设置负载均衡静态路由`static:failover://(tcp://localhost:61618,tcp://localhost:61619)`,然后启动
- - 从：上面的基础上修改tcp服务端口为61617,然后启动
-- brokerB:
- - 主：设置web管理端口8762，设置mq名称`mq1`,设置数据库地址activemq1，设置tcp服务端口61618，设置负载均衡静态路由`static:failover://(tcp://localhost:61616,tcp://localhost:61617)`,然后启动
- - 从：上面的基础上修改tcp服务端口为61619，然后启动
-
-#### 2、springboot测试
-
- 沿用上一篇的项目，修改配置文件的broker-url为`failover:(tcp://localhost:61616,tcp://localhost:61617,tcp://localhost:61618,tcp://localhost:61619)`，然后启动项目访问会在控制台看到如下日志：
-
-```java
-2018-07-31 15:09:25.076 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
-1I'm from queue1:hello
-2018-07-31 15:09:26.599 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
-2I'm from queue1:hello
-2018-07-31 15:09:29.002 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61616
-1I'm from queue1:hello
-2018-07-31 15:09:34.931 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
-2I'm from queue1:hello
-```
-
+ 单个MQ节点总是不可靠的，一旦该节点出现故障，MQ服务就不可用了，势必会产生较大的损失。这里记录activeMQ如何开启主从备份，一旦master（主节点故障），slave（从节点）立即提供服务，实现原理是运行多个MQ使用同一个持久化数据源，这里以jdbc数据源为例。同一时间只有一个节点（节点A）能够抢到数据库的表锁，其他节点进入阻塞状态，一旦A发生错误崩溃，其他节点就会重新获取表锁，获取到锁的节点成为master，其他节点为slave，如果节点A重新启动，也将成为slave。
+
+ 主从备份解决了单节点故障的问题，但是同一时间提供服务的只有一个master，显然是不能面对数据量的增长，所以需要一种横向拓展的集群方式来解决面临的问题。
+
+### 一、activeMQ设置
+
+#### 1、平台版本说明：
+
+- 平台：windows
+- activeMQ版本：5.9.1，[下载地址](https://www.apache.org/dist/activemq/5.9.1/apache-activemq-5.9.1-bin.zip.asc)
+- jdk版本：1.8
+
+#### 2、下载jdbc依赖
+
+ 下载下面三个依赖包，放到activeMQ安装目录下的lib文件夹中。
+
+[mysql驱动](http://central.maven.org/maven2/mysql/mysql-connector-java/5.1.38/mysql-connector-java-5.1.38.jar)
+
+[dhcp依赖](http://central.maven.org/maven2/org/apache/commons/commons-dbcp2/2.1.1/commons-dbcp2-2.1.1.jar)
+
+[commons-pool2依赖](http://maven.aliyun.com/nexus/service/local/artifact/maven/redirect?r=jcenter&g=org.apache.commons&a=commons-pool2&v=2.6.0&e=jar)
+
+###二、主从备份
+
+####1、修改jettty
+
+ 首先修改conf->jetty.xml，这里是修改activemq的web管理端口，管理界面账号密码默认为admin/admin
+
+```xml
+
+
+
+
+```
+
+####2、修改activemq.xml
+
+ 然后修改conf->activemq.xml
+
+- 设置连接方式
+
+ 默认是下面五种连接方式都打开，这里我们只要tcp，把其他的都注释掉，然后在这里设置activemq的服务端口，可以看到每种连接方式都对应一个端口。
+
+ ```xml
+
+
+
+
+
+ ```
+
+
+
+- 设置jdbc数据库
+
+ mysql数据库中创建activemq库，在`broker`标签的下面也就是根标签`beans`的下一级创建一个bean节点，内容如下：
+
+ ```xml
+
+
+
+
+
+
+
+ ```
+
+- 设置数据源
+
+ 首先修改broker节点，设置name和persistent(默认为true),也可不做修改，修改后如下：
+
+ ```xml
+
+ ```
+
+ 然后设置持久化方式,使用到我们之前设置的mysql-qs
+
+ ```xml
+
+
+
+
+ ```
+
+#### 3、启动
+
+ 设置完毕后启动activemq（双击bin中的acitveMQ.jar)，启动完成后可以看到如下日志信息：
+
+```verilog
+ INFO | Using a separate dataSource for locking: org.apache.commons.dbcp2.BasicDataSource@179ece50
+ INFO | Attempting to acquire the exclusive lock to become the Master broker
+ INFO | Becoming the master on dataSource: org.apache.commons.dbcp2.BasicDataSource@179ece50
+```
+
+ 接着我们修改一下tcp服务端口，改为61617，然后重新启动，日志信息如下：
+
+```verilog
+ INFO | Using a separate dataSource for locking: org.apache.commons.dbcp2.BasicDataSource@179ece50
+ INFO | Attempting to acquire the exclusive lock to become the Master broker
+ INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
+ INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
+ INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
+ INFO | Failed to acquire lock. Sleeping for 10000 milli(s) before trying again...
+```
+
+可以看到从节点一直在尝试获取表锁成为主节点，这样一旦主节点失效，从节点能够立刻取代主节点提供服务。这样我们便实现了主从备份。
+
+### 三、负载均衡
+
+ activemq可以实现多个mq之间进行路由，假设有两个mq，分别为brokerA和brokerB，当一条消息发送到brokerA的队列test中，有一个消费者连上了brokerB，并且想要获取test队列，brokerA中的test队列就会路由到brokerB上。
+
+ 开启负载均衡需要设置`networkConnectors`节点，静态路由配置如下：
+
+```xml
+
+
+
+```
+
+brokerA和brokerB都要设置该配置，以连上对方。
+
+### 四、测试
+
+####1、建立mq
+
+ 组建两组broker，每组做主从配置。
+
+- brokerA：
+ - 主：设置web管理端口8761,设置mq名称`mq`,设置数据库地址为activemq，设置tcp服务端口61616，设置负载均衡静态路由`static:failover://(tcp://localhost:61618,tcp://localhost:61619)`,然后启动
+ - 从：上面的基础上修改tcp服务端口为61617,然后启动
+- brokerB:
+ - 主：设置web管理端口8762，设置mq名称`mq1`,设置数据库地址activemq1，设置tcp服务端口61618，设置负载均衡静态路由`static:failover://(tcp://localhost:61616,tcp://localhost:61617)`,然后启动
+ - 从：上面的基础上修改tcp服务端口为61619，然后启动
+
+#### 2、springboot测试
+
+ 沿用上一篇的项目，修改配置文件的broker-url为`failover:(tcp://localhost:61616,tcp://localhost:61617,tcp://localhost:61618,tcp://localhost:61619)`，然后启动项目访问会在控制台看到如下日志：
+
+```java
+2018-07-31 15:09:25.076 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
+1I'm from queue1:hello
+2018-07-31 15:09:26.599 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
+2I'm from queue1:hello
+2018-07-31 15:09:29.002 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61616
+1I'm from queue1:hello
+2018-07-31 15:09:34.931 INFO 12780 --- [ActiveMQ Task-1] o.a.a.t.failover.FailoverTransport : Successfully connected to tcp://localhost:61618
+2I'm from queue1:hello
+```
+
证明负载均衡成功。
\ No newline at end of file
diff --git a/springboot系列/读写分离配置/springboot配置读写分离.md b/springboot系列/读写分离配置/springboot配置读写分离.md
new file mode 100644
index 0000000..e37054a
--- /dev/null
+++ b/springboot系列/读写分离配置/springboot配置读写分离.md
@@ -0,0 +1,311 @@
+ 近日工作任务较轻，有空学习学习技术，遂来研究如果实现读写分离。这里用博客记录下过程，一方面可备日后查看，同时也能分享给大家（网上的资料真的大都是抄来抄去，，还不带格式的，看的真心难受）。
+
+[完整代码](https://github.com/FleyX/demo-project/tree/master/dxfl)
+
+## 1、背景
+
+ 一个项目中数据库最基础同时也是最主流的是单机数据库，读写都在一个库中。当用户逐渐增多，单机数据库无法满足性能要求时，就会进行读写分离改造（适用于读多写少），写操作一个库，读操作多个库，通常会做一个数据库集群，开启主从备份，一主多从，以提高读取性能。当用户更多读写分离也无法满足时，就需要分布式数据库了（可能以后会学习怎么弄）。
+
+ 正常情况下读写分离的实现，首先要做一个一主多从的数据库集群，同时还需要进行数据同步。这一篇记录如何用mysql搭建一个一主多次的配置，下一篇记录代码层面如何实现读写分离。
+
+## 2、搭建一主多从数据库集群
+
+ 主从备份需要多台虚拟机，我是用wmware完整克隆多个实例，注意直接克隆的虚拟机会导致每个数据库的uuid相同，需要修改为不同的uuid。修改方法参考这个：[点击跳转](https://blog.csdn.net/pratise/article/details/80413198)。
+
+- 主库配置
+
+ 主数据库（master）中新建一个用户用于从数据库（slave）读取主数据库二进制日志，sql语句如下：
+
+ ```sql
+ mysql> CREATE USER 'repl'@'%' IDENTIFIED BY '123456';#创建用户
+ mysql> GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';#分配权限
+ mysql>flush privileges; #刷新权限
+ ```
+
+ 同时修改mysql配置文件开启二进制日志，新增部分如下：
+
+ ```sql
+ [mysqld]
+ server-id=1
+ log-bin=master-bin
+ log-bin-index=master-bin.index
+ ```
+
+ 然后重启数据库，使用`show master status;`语句查看主库状态，如下所示：
+
+
+
+- 从库配置
+
+ 同样先新增几行配置：
+
+ ```sql
+ [mysqld]
+ server-id=2
+ relay-log-index=slave-relay-bin.index
+ relay-log=slave-relay-bin
+ ```
+
+ 然后重启数据库，使用如下语句连接主库：
+
+ ```sql
+ CHANGE MASTER TO
+ MASTER_HOST='192.168.226.5',
+ MASTER_USER='root',
+ MASTER_PASSWORD='123456',
+ MASTER_LOG_FILE='master-bin.000003',
+ MASTER_LOG_POS=154;
+ ```
+
+ 接着运行`start slave;`开启备份,正常情况如下图所示：Slave_IO_Running和Slave_SQL_Running都为yes。
+
+ 
+
+ 可以用这个步骤开启多个从库。
+
+ 默认情况下备份是主库的全部操作都会备份到从库，实际可能需要忽略某些库，可以在主库中增加如下配置：
+
+```sql
+# 不同步哪些数据库
+binlog-ignore-db = mysql
+binlog-ignore-db = test
+binlog-ignore-db = information_schema
+
+# 只同步哪些数据库，除此之外，其他不同步
+binlog-do-db = game
+```
+
+## 3、代码层面进行读写分离
+
+ 代码环境是springboot+mybatis+druib连接池。想要读写分离就需要配置多个数据源，在进行写操作是选择写的数据源，读操作时选择读的数据源。其中有两个关键点：
+
+- 如何切换数据源
+- 如何根据不同的方法选择正确的数据源
+
+### 1)、如何切换数据源
+
+ 通常用springboot时都是使用它的默认配置，只需要在配置文件中定义好连接属性就行了，但是现在我们需要自己来配置了，spring是支持多数据源的，多个datasource放在一个HashMap`TargetDataSource`中，通过`dertermineCurrentLookupKey`获取key来觉定要使用哪个数据源。因此我们的目标就很明确了，建立多个datasource放到TargetDataSource中，同时重写dertermineCurrentLookupKey方法来决定使用哪个key。
+
+### 2)、如何选择数据源
+
+ 事务一般是注解在Service层的，因此在开始这个service方法调用时要确定数据源，有什么通用方法能够在开始执行一个方法前做操作呢？相信你已经想到了那就是**切面 **。怎么切有两种办法：
+
+- 注解式，定义一个只读注解，被该数据标注的方法使用读库
+- 方法名，根据方法名写切点，比如getXXX用读库，setXXX用写库
+
+### 3)、代码编写
+
+#### a、编写配置文件，配置两个数据源信息
+
+ 只有必填信息，其他都有默认设置
+
+```yml
+mysql:
+ datasource:
+ #读库数目
+ num: 1
+ type-aliases-package: com.example.dxfl.dao
+ mapper-locations: classpath:/mapper/*.xml
+ config-location: classpath:/mybatis-config.xml
+ write:
+ url: jdbc:mysql://192.168.226.5:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
+ username: root
+ password: 123456
+ driver-class-name: com.mysql.jdbc.Driver
+ read:
+ url: jdbc:mysql://192.168.226.6:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
+ username: root
+ password: 123456
+ driver-class-name: com.mysql.jdbc.Driver
+```
+
+#### b、编写DbContextHolder类
+
+ 这个类用来设置数据库类别，其中有一个ThreadLocal用来保存每个线程的是使用读库，还是写库。代码如下：
+
+```java
+/**
+ * Description 这里切换读/写模式
+ * 原理是利用ThreadLocal保存当前线程是否处于读模式（通过开始READ_ONLY注解在开始操作前设置模式为读模式，
+ * 操作结束后清除该数据，避免内存泄漏，同时也为了后续在该线程进行写操作时任然为读模式
+ * @author fxb
+ * @date 2018-08-31
+ */
+public class DbContextHolder {
+
+ private static Logger log = LoggerFactory.getLogger(DbContextHolder.class);
+ public static final String WRITE = "write";
+ public static final String READ = "read";
+
+ private static ThreadLocal contextHolder= new ThreadLocal<>();
+
+ public static void setDbType(String dbType) {
+ if (dbType == null) {
+ log.error("dbType为空");
+ throw new NullPointerException();
+ }
+ log.info("设置dbType为：{}",dbType);
+ contextHolder.set(dbType);
+ }
+
+ public static String getDbType() {
+ return contextHolder.get() == null ? WRITE : contextHolder.get();
+ }
+
+ public static void clearDbType() {
+ contextHolder.remove();
+ }
+}
+```
+
+#### c、重写determineCurrentLookupKey方法
+
+ spring在开始进行数据库操作时会通过这个方法来决定使用哪个数据库，因此我们在这里调用上面DbContextHolder类的`getDbType()`方法获取当前操作类别,同时可进行读库的负载均衡，代码如下：
+
+```java
+public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {
+
+ @Value("${mysql.datasource.num}")
+ private int num;
+
+ private final Logger log = LoggerFactory.getLogger(this.getClass());
+
+ @Override
+ protected Object determineCurrentLookupKey() {
+ String typeKey = DbContextHolder.getDbType();
+ if (typeKey == DbContextHolder.WRITE) {
+ log.info("使用了写库");
+ return typeKey;
+ }
+ //使用随机数决定使用哪个读库
+ int sum = NumberUtil.getRandom(1, num);
+ log.info("使用了读库{}", sum);
+ return DbContextHolder.READ + sum;
+ }
+}
+```
+
+#### d、编写配置类
+
+ 由于要进行读写分离，不能再用springboot的默认配置，我们需要手动来进行配置。首先生成数据源，使用@ConfigurProperties自动生成数据源：
+
+```java
+ /**
+ * 写数据源
+ *
+ * @Primary 标志这个 Bean 如果在多个同类 Bean 候选时，该 Bean 优先被考虑。
+ * 多数据源配置的时候注意，必须要有一个主数据源，用 @Primary 标志该 Bean
+ */
+ @Primary
+ @Bean
+ @ConfigurationProperties(prefix = "mysql.datasource.write")
+ public DataSource writeDataSource() {
+ return new DruidDataSource();
+ }
+```
+
+读数据源类似，注意有多少个读库就要设置多少个读数据源，Bean名为read+序号。
+
+ 然后设置数据源，使用的是我们之前写的MyAbstractRoutingDataSource类
+
+```java
+ /**
+ * 设置数据源路由，通过该类中的determineCurrentLookupKey决定使用哪个数据源
+ */
+ @Bean
+ public AbstractRoutingDataSource routingDataSource() {
+ MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource();
+ Map targetDataSources = new HashMap<>(2);
+ targetDataSources.put(DbContextHolder.WRITE, writeDataSource());
+ targetDataSources.put(DbContextHolder.READ+"1", read1());
+ proxy.setDefaultTargetDataSource(writeDataSource());
+ proxy.setTargetDataSources(targetDataSources);
+ return proxy;
+ }
+```
+
+ 接着需要设置sqlSessionFactory
+
+```java
+ /**
+ * 多数据源需要自己设置sqlSessionFactory
+ */
+ @Bean
+ public SqlSessionFactory sqlSessionFactory() throws Exception {
+ SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
+ bean.setDataSource(routingDataSource());
+ ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
+ // 实体类对应的位置
+ bean.setTypeAliasesPackage(typeAliasesPackage);
+ // mybatis的XML的配置
+ bean.setMapperLocations(resolver.getResources(mapperLocation));
+ bean.setConfigLocation(resolver.getResource(configLocation));
+ return bean.getObject();
+ }
+```
+
+ 最后还得配置下事务，否则事务不生效
+
+```java
+ /**
+ * 设置事务，事务需要知道当前使用的是哪个数据源才能进行事务处理
+ */
+ @Bean
+ public DataSourceTransactionManager dataSourceTransactionManager() {
+ return new DataSourceTransactionManager(routingDataSource());
+ }
+```
+
+### 4)、选择数据源
+
+ 多数据源配置好了，但是代码层面如何选择选择数据源呢？这里介绍两种办法：
+
+#### a、注解式
+
+ 首先定义一个只读注解，被这个注解方法使用读库，其他使用写库，如果项目是中途改造成读写分离可使用这个方法，无需修改业务代码，只要在只读的service方法上加一个注解即可。
+
+```java
+@Target({ElementType.METHOD,ElementType.TYPE})
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ReadOnly {
+}
+```
+
+ 然后写一个切面来切换数据使用哪种数据源，重写getOrder保证本切面优先级高于事务切面优先级，在启动类加上`@EnableTransactionManagement(order = 10) `,为了代码如下：
+
+```java
+@Aspect
+@Component
+public class ReadOnlyInterceptor implements Ordered {
+ private static final Logger log= LoggerFactory.getLogger(ReadOnlyInterceptor.class);
+
+ @Around("@annotation(readOnly)")
+ public Object setRead(ProceedingJoinPoint joinPoint,ReadOnly readOnly) throws Throwable{
+ try{
+ DbContextHolder.setDbType(DbContextHolder.READ);
+ return joinPoint.proceed();
+ }finally {
+ //清楚DbType一方面为了避免内存泄漏，更重要的是避免对后续在本线程上执行的操作产生影响
+ DbContextHolder.clearDbType();
+ log.info("清除threadLocal");
+ }
+ }
+
+ @Override
+ public int getOrder() {
+ return 0;
+ }
+}
+```
+
+#### b、方法名式
+
+ 这种方法不许要注解，但是需要事务名称按一定规则编写，然后通过切面来设置数据库类别，比如`setXXX`设置为写、`getXXX`设置为读，代码我就不写了，应该都知道怎么写。
+
+### 4、测试
+
+ 编写好代码来试试结果如何，下面是运行截图：
+
+
+
+ 断断续续写了好几天终于是写完了，，，如果有帮助到你，，欢迎star哦，，这里是完整代码地址：[点击跳转](https://github.com/FleyX/demo-project/tree/master/dxfl)
\ No newline at end of file
diff --git a/springboot系列/读写分离配置/读写分离配置/pic1.png b/springboot系列/读写分离配置/读写分离配置/pic1.png
new file mode 100644
index 0000000..32f919c
Binary files /dev/null and b/springboot系列/读写分离配置/读写分离配置/pic1.png differ
diff --git a/springboot系列/读写分离配置/读写分离配置/pic2.png b/springboot系列/读写分离配置/读写分离配置/pic2.png
new file mode 100644
index 0000000..9f9c501
Binary files /dev/null and b/springboot系列/读写分离配置/读写分离配置/pic2.png differ
diff --git a/springboot系列/读写分离配置/读写分离配置/pic3.png b/springboot系列/读写分离配置/读写分离配置/pic3.png
new file mode 100644
index 0000000..84a4538
Binary files /dev/null and b/springboot系列/读写分离配置/读写分离配置/pic3.png differ