# AvengersBack

**Repository Path**: JokerPan12/avengers-back

## Basic Information

- **Project Name**: AvengersBack
- **Description**: Avengers后台
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2022-03-11
- **Last Updated**: 2023-05-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: Java, SpringBoot, springscurity

## README

#  Avengers SpringBoot后端项目打包操作说明
1.修改`pom.xml`和`application.yml`:

`pom.xml` [注释部分打包时取消注释]
```
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging> <!--打包成war包-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
        <relativePath/>
    </parent>
    <groupId>com.jokerpan</groupId>
    <artifactId>jokerpanback</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>JokerPanBack</name>
    <description>JokerPans Project</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!-- 排除springboot内置tomcat容器的SpringBootServletInitializer接口需要依赖 javax.servlet -->
<!--        <dependency>-->
<!--            <groupId>javax.servlet</groupId>-->
<!--            <artifactId>javax.servlet-api</artifactId>-->
<!--            <version>3.1.0</version>-->
<!--            <scope>provided</scope>-->
<!--        </dependency>-->
        <!-- 本地调试集成tomcat -->
<!--        <dependency>-->
<!--            <groupId>org.apache.tomcat</groupId>-->
<!--            <artifactId>tomcat-servlet-api</artifactId>-->
<!--            <version>8.0.36</version>-->
<!--            <scope>provided</scope>-->
<!--        </dependency>-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-autoconfigure</artifactId>
            <version>2.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.9</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.9</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.1</version>
        </dependency>
        <!-- mysql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>

        <resources>
            <resource>
                <directory>src/main/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>
</project>
```

`application.yml` [注释部分同上，打包前取消]
```
server:
  tomcat:
    uri-encoding: UTF-8
    max-threads: 1000
    min-spare-threads: 30
  port: 8088
#  servlet:
#    context-path: /jokerpanBack        #这里填写与打包好的war包相同的名字

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://#服务器地址:#数据库端口【一般是3306】/#数据库名称?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=false
    username: #数据库用户名
    password: #数据库密码
    initial-size: 10
    max-active: 100
    min-idle: 10
    max-wait: 60000
    pool-prepared-statements: true
    max-pool-prepared-statement-per-connection-size: 20
    time-between-eviction-runs-millis: 60000
    min-evictable-idle-time-millis: 300000
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
    filter:
        stat:
            log-slow-sql: true
            slow-sql-millis: 1000
            merge-sql: true
    wall:
        config:
            multi-statement-allow: true


# Mybatis配置
mybatis:
  mapperLocations: classpath:mapper/**/*.xml
  configuration:
    mapUnderscoreToCamelCase: true  # 驼峰转换
```
    
    2.在服务器中安装 tomcat

    3.在maven界面-Lifecycle 下点击package打包成war包，打包后会在项目根目录-target下看到类似
    【项目名-0.0.1-SNAPSHOT.war】这样的文件说明已经打包好了；然后可以重命名上传此文件到刚刚安
    装好的tomcat文件夹/webapps下

    4.用命令进入刚才安装的tomcat文件夹/bin目录下；运行`./startup.sh` 启动tomcat服务

    5.使用 http://服务器地址:端口/刚才配置的context-path/ 就可以访问到后端接口了


# SpringBoot整合SpringCloud nacos

1.下载nacos压缩包
`https://github.com/alibaba/nacos.git`

2.上传到服务器中并解压到 `/usr/local/nacos`目录

3.用命令进入 `/usr/local/nacos/bin/` 目录下并运行 `./startup.sh -m standalone` 命令启动单机模式

4.浏览器输入 `http://ip:8848/nacos` 就可以访问到nacos主页面了，账号密码都是 `nacos`,访问前记得开放 `8848` nacos默认端口

5.在 `pom.xml` 中导入依赖:

```
<properties>
     <java.version>1.8</java.version>
    <nacos-config-spring-boot.version>0.2.1</nacos-config-spring-boot.version>
    <nacos-discovery-spring-boot.version>0.2.1</nacos-discovery-spring-boot.version>
    <spring-cloud-starter-alibaba-nacos.version>2.1.3.RELEASE</spring-cloud-starter-alibaba-nacos.version>
    <nacos-api.version>1.4.1</nacos-api.version>
</properties>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>${spring-cloud-starter-alibaba-nacos.version}</version>
</dependency>

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    <version>${spring-cloud-starter-alibaba-nacos.version}</version>
</dependency>

若因版本问题导致启动失败可尝试更改以下版本：

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

```

6.新增 `bootstrap.yml` 文件

```

spring:
  application:
    name: @artifactId@
  profiles:
    active:  @profile.name@
  cloud:
    nacos:
      #配置nacos命名空间与地址
      config:
        namespace: @config.namespace@   #${config.namespace}
        server-addr:  @config.server-addr@    #${config.server-addr}
        #读取文件类型
        file-extension: yml
#        shared-dataids: application.yml
#        refreshable-dataids: application.yml
        username: @config.username@     #${config.username}
        password: @config.password@      #${config.password}
      #配置服务发现
      discovery:
        namespace: @config.namespace@          #${config.namespace}
        server-addr: @discovery.server-addr@     #${discovery.server-addr}
        username:  @config.username@  #${config.username}
        password: @config.password@    #${config.password}

  main:
    allow-bean-definition-overriding: true

以上 `@ @`符号指向 `pom.xml` 文件中的 `<profile></profile>`

<profiles>
        <!--可设置多个profile通过active控制-->
        <!--开发环境-->
        <profile>
            <id>dev</id>
            <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
                <profile.name>dev</profile.name>
                <config.server-addr>#nacos地址</config.server-addr>
                <config.namespace>public</config.namespace>
                <config.username>nacos</config.username>
                <config.password>nacos</config.password>
                <discovery.server-addr>#nacos地址</discovery.server-addr>
                <discovery.server-ip>#nacosIP</discovery.server-ip>
            </properties>
        </profile>
        <!--正式环境-->
        <profile>
            <id>on-line</id>
<!--            <activation>-->
<!--                <activeByDefault>true</activeByDefault>-->
<!--            </activation>-->
            <properties>
                <profile.name>online</profile.name>
                <config.server-addr>#nacos地址</config.server-addr>
                <config.namespace>public</config.namespace>
                <config.username>nacos</config.username>
                <config.password>nacos</config.password>
                <discovery.server-addr>#nacos地址</discovery.server-addr>
                <discovery.server-ip>#nacosIP</discovery.server-ip>
            </properties>
        </profile>
</profiles>

```

7.在nacos中新增开发环境以及线上环境的配置

```
在 Nacos Spring Cloud 中，dataId 的完整格式如下：

${prefix}-${spring.profiles.active}.${file-extension}
prefix 默认为 spring.application.name 的值，也可以通过配置项 spring.cloud.nacos.config.prefix来配置。
spring.profiles.active 即为当前环境对应的 profile，详情可以参考 Spring Boot文档。 注意：当 spring.profiles.active 为空时，对应的连接符 - 也将不存在，dataId 的拼接格式变成 ${prefix}.${file-extension}
file-exetension 为配置内容的数据格式，可以通过配置项 spring.cloud.nacos.config.file-extension 来配置。目前只支持 properties 和 yaml 类型。

```

8.配置完成后就可以删除 `application.yml` 文件了，不过还需在 `pom.xml` 配置扫描新增的 `bootstrap.yml`

```
<resources>
            <resource>
                <directory>src/main/java</directory>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
                <filtering>true</filtering>
            </resource>
</resources>

```

9.Controller 可增加以下注解：

```

@RefreshScope   //对Bean进行动态刷新，添加 @RefreshScope 或 @ConfigurationProperties注解。
public class UsersController {

    //可使用@Value获取nacos中的配置信息
    @Value("${server.port}")
    public String port;

```

10.配置nacos连接数据库:

（1）进入 `/nacos/conf` 目录下；
（2）使用 `nacos-mysql.sql` 文件初始化数据库；
（3）编辑 `application.properties` 配置文件：

```

spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://ip:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=root
db.password=1234

```

11.重启nacos,进入主页面可新增命名空间，新增后可以在数据库 `tenant_info` 表中看见记录；
注：如果不能新增命名空间可以先清除浏览器缓存然后再试试;
`如果在 pom.xml 使用新命名空间后加载不到配置可尝试更换为命名空间的 id; 例如：`

```
<config.namespace>44fedf1c-479a-4fc9-974f-b1049cad8e00</config.namespace>
```

12.修改nacos登录密码：
一般安装nacos后登录密码默认都是nacos/nacos，但是在正式的生成环境这样肯定是不安全的;
查看nacos源码加密方式,nacos底层源码是BCryptPasswordEncoder加密器加密的:

```
package com.alibaba.nacos.console.utils;

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

/**
 * Password encoder tool
 *
 * @author nacos
 */
public class PasswordEncoderUtil {

    public static void main(String[] args) {
        System.out.println(new BCryptPasswordEncoder().encode("nacos"));
    }

    public static Boolean matches(String raw, String encoded) {
        return new BCryptPasswordEncoder().matches(raw, encoded);
    }

    public static String encode(String raw) {
        return new BCryptPasswordEncoder().encode(raw);
    }
}

```

这样的话我们就可以用类似的方法去加密:

`·导入Security的依赖`

```
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
```

`·得到加密后的字符`

```
public class UserServerApplication {
    public static void main(String[] args) {
        System.out.println(new BCryptPasswordEncoder().encode("123456"));
    }
}

```

```
$2a$10$Ca5DCqgaiGHaZnlmxhbBZOoCyfJvt9tFAnlnUHEjOdlHxnVKDxf9W

Process finished with exit code 0
```

然后在数据库中找到 `users` 表，然后把刚才得到的密文加进去;

当然如果想改默认账户 `nacos` 的密码直接在主页面右上角点击修改密码即可；

导入Security依赖后访问接口的话会需要权限登录，此时如果我们不需要权限功能的话可以禁用它：

```
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
//禁用Spring-Security
@EnableAutoConfiguration(exclude = {org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class})

```

记得改完用户名和密码要去 `pom.xml` 文件里更新。


# 整合阿里云OSS文件对象存储

1.在阿里云官网购买 `OSS` 服务；

2.创建 `Bucket` ，填写Bucket名称，选择地域，读写权限选择 `公共读` ,其他选项默认, 记住Bucket的 `endpoint`；

3.创建阿里云 API 密钥 `AccessKey`,记住 `AccessKey ID` 以及 `AccessKey Secret`;

4.在 `nacos` 中配置：

```
aliyun:
  oss:
    endpoint: oss-cn-guangzhou.aliyuncs.com
    accessKeyId: xxx
    accessKeySecret: xxx
    bucketName: #刚才创建Bucket的名称
```

5.创建阿里云对象存储配置类读取 `nacos` 中的配置

```
/**
 * 阿里云对象存储配置类
 * @author jokerpan
 */
@Configuration
@ConfigurationProperties(prefix = "aliyun.oss")
public class AliyunOssConfig {

    private String endpoint;

    private String accessKeyId;

    private String accessKeySecret;

    private String bucketName;

    public String getEndpoint() {
        return endpoint;
    }

    public void setEndpoint(String endpoint) {
        this.endpoint = endpoint;
    }
    
    ................
```

6.使用 `oss` 进行文件上传:

```
@Resource
AliyunOssConfig aliyunOssConfig;

 /**
 * 保存至aliyun Oss
 * @param path
 * @param fileBytes
 * @return
 */
public boolean saveToOss(String path, byte[] fileBytes) {
    boolean ok = true;

    OSS ossClient = new OSSClientBuilder().build(aliyunOssConfig.getEndpoint(),                         
    aliyunOssConfig.getAccessKeyId(),aliyunOssConfig.getAccessKeySecret());

    try {
        // 创建PutObjectRequest对象。
        // 填写Bucket名称和Object完整路径。Object完整路径中不能包含Bucket名称。
        PutObjectRequest putObjectRequest = new PutObjectRequest(aliyunOssConfig.getBucketName(), path, new ByteArrayInputStream(fileBytes));

        PutObjectResult res = ossClient.putObject(putObjectRequest);
    } catch (Exception e) {
        ok = false;
        e.printStackTrace();
    }

    ossClient.shutdown();

    return ok;
}
```

7.根据文件路径删除对应的文件(注：切忌文件路径已 `/` 或 '\' 开头)：

```
public boolean deleteFile(String path) {
        boolean ok = true;
        path = path.split("com")[1].substring(1);
        // 创建OSSClient实例。
        OSS ossClient = new OSSClientBuilder().build(aliyunOssConfig.getEndpoint(), 
        aliyunOssConfig.getAccessKeyId(),aliyunOssConfig.getAccessKeySecret());
        try {
            // 判断文件是否存在
            boolean found = ossClient.doesObjectExist(aliyunOssConfig.getBucketName(), path);
            if (found) {
                // 删除附件
                ossClient.deleteObject(aliyunOssConfig.getBucketName(), path);
            }
        } catch (Exception e) {
            ok = false;
            e.printStackTrace();
        }
        // 关闭OSSClient。
        ossClient.shutdown();

        return ok;
    }
```

8.到这里就基本告一段落了，快去试试吧！


# 整合Redis

1.服务器安装 `redis`;

2.在安装路径中找到redis配置文件 `redis.conf` 并进行如下修改：

```
(1) 找到bind 127.0.0.1并注释掉, 默认127.0.0.1只能本地访问，注释掉即可ip访问

(2) 修改 protected-mode 属性值为no, 保护模式禁用以后可以IP访问

(3) 修改daemonize属性将no 改为yes, 将daemonize设置为yes即启动后台运行
```

3.开放redis默认端口 `6379`

4.启动redis并测试连接：
```
redis-cli -h 192.168.126.129 -p 6379
```
```
root@JokerPanBase:/# redis-cli -h 120.24.168.122 -p 6379
120.24.168.122:6379> 

以上代表连接成功!
```

5.在 `nacos` 中配置：
```
#redis jedis配置
  redis:
    #redis 数据库索引，默认为0
    database: 0
    #服务器地址
    host: 120.24.168.122
    #端口
    port: 6379
    #redis 服务器密码，默认为空
    password:
    pool:
      #连接池最大阻塞等待时间（使用负值表示没有限制）
      max-wait: 30000  
      #连接池最大链接数
      max-active: 200
      #连接池中最大空闲链接
      max-idle: 8
      #连接池最小空闲链接
      min-idle: 0
    #链接超时
    timeout: 0

```

6.在 `pom.xml` 加入依赖：
```
        <!-- redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>
```

7.增加redis配置类
```
/**
 * @author jokerpan
 */
public class RedisConfig  extends CachingConfigurerSupport {
    /**
     * 选择redis作为默认缓存工具
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        // 设置缓存有效期一小时
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1));
        return RedisCacheManager
                .builder(RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory))
                .cacheDefaults(redisCacheConfiguration).build();
    }

    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}
```

8.测试redis缓存:

```
 /**
     * redis 测试
     */
    public Users findUserById(Integer id){
        String key = "user_" + id;
        ValueOperations<String, Users> operations = redisTemplate.opsForValue();
        //判断redis中是否有键为key的缓存
        boolean hasKey = redisTemplate.hasKey(key);
        Users users = usersMapper.queryById(id);
        if (!hasKey){
            // 写入缓存
            operations.set(key, users, 5, TimeUnit.HOURS);
        }else {
            //根据key删除
            redisTemplate.delete(key);
        }
        return users;
    }
```


# 整合Spring Security

1.导入 `Security` 依赖, 数据库新建角色表、权限表等等

```
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.security</groupId>
            <artifactId>spring-security-web</artifactId>
        </dependency>
```

2.配置 `SpringSecurity` ,自定义的处理逻辑详情请看项目中的 `Handler` 文件夹内

```
package com.jokerpan.project.config;
import com.jokerpan.project.Handler.*;
import com.jokerpan.project.service.impl.UsersServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import javax.annotation.Resource;

/**
 * SpringSecurity配置
 * @author jokerpan
 */
@EnableWebSecurity
//开启权限注解,默认是关闭的
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)
public class SpringSecurityConfig extends WebSecurityConfigurerAdapter {

    /**
     * 未登录
     */
    @Resource
    AuthenticationEnryPoint authenticationEnryPoint;
    /**
     * 登录成功
     */
    @Resource
    AuthenticationSuccess authenticationSuccess;
    /**
     * 登录失败
     */
    @Resource
    AuthenticationFailure authenticationFailure;
    /**
     * 注销
     */
    @Resource
    AuthenticationLogout authenticationLogout;
    /**
     * 无权访问
     */
    @Resource
    AccessDeny accessDeny;
    /**
     * 检测异地登录
     */
    @Resource
    SessionInformationExpiredStrategy sessionInformationExpiredStrategy;
    /**
     * 自定义认证逻辑处理
     */
    @Resource
    SelfAuthenticationProvider selfAuthenticationProvider;

    @Bean
    public UserDetailsService userDetailsService() {
        return new UsersServiceImpl();
    }

    /**
     * 加密方式
     */
    @Bean
    public BCryptPasswordEncoder bCryptPasswordEncoder() {
        return new BCryptPasswordEncoder();
    }

    /**
     * 认证
     */
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.authenticationProvider(selfAuthenticationProvider);
    }

    /**
     * 授权
     */
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //cors()解决跨域问题，csrf()会与restful风格冲突，默认springsecurity是开启的，所以要disable()关闭一下
        http.cors().and().csrf().disable();

        //     /index需要权限为ROLE_USER才能访问   /hello需要权限为ROLE_ADMIN才能访问
        http.authorizeRequests()
                //开放注册接口允许所有人访问
                .antMatchers("/users/register").permitAll()
                //hasAuthority 跟数据库权限保持一致【ROLE_ADMIN】而 hasRole则需要数据库中已ROLE开头
//                .antMatchers("/users/*").hasAnyRole("ADMIN", "USER")
//                .antMatchers("/users/queryList").hasRole("USER")

                .and()
                //开启登录
                .formLogin()
                //允许所有人访问
                .permitAll()
                // 登录成功逻辑处理
                .successHandler(authenticationSuccess)
                // 登录失败逻辑处理
                .failureHandler(authenticationFailure)

                .and()
                //开启注销
                .logout()
                //允许所有人访问
                .permitAll()
                //注销逻辑处理
                .logoutSuccessHandler(authenticationLogout)
                //删除cookie
                .deleteCookies("JSESSIONID")

                .and().exceptionHandling()
                //权限不足的时候的逻辑处理
                .accessDeniedHandler(accessDeny)
                //未登录是的逻辑处理
                .authenticationEntryPoint(authenticationEnryPoint)

                .and()
                .sessionManagement()
                //最多只能一个用户登录一个账号
                .maximumSessions(1)
                //异地登录的逻辑处理
                .expiredSessionStrategy(sessionInformationExpiredStrategy);
    }
}

```

3.查询用户信息实现类要实现 `UserDetailsService` 接口中的 `loadUserByUsername` 方法:

```
    @Override
    public UserDetails loadUserByUsername(String loginName) throws UsernameNotFoundException {
        Users users = usersMapper.checkLoginName(loginName);
        if (users == null){
            throw new UsernameNotFoundException("用户名错误！！");
        }
        //获取用户权限，并把其添加到GrantedAuthority中
        List<GrantedAuthority> grantedAuthorities=new ArrayList<>();
        GrantedAuthority grantedAuthority=new SimpleGrantedAuthority(users.getRoleName());
        grantedAuthorities.add(grantedAuthority);
        //方法的返回值要求返回UserDetails这个数据类型，  UserDetails是接口，找它的实现类就好了
        return new org.springframework.security.core.userdetails.User(loginName,users.getPassword(),grantedAuthorities);
    }

在这里说明一下：Security 中密码是通过 `BCryptPasswordEncoder()` 自带方法加密的，所以数据库中的密码最好也用这种加密方式不然就会判断密码错误
```

4.在这里踩一下坑，如果是前后端分离并且 `application.yml` 中配置了：

```
  servlet:
    context-path: /jokerpanBack
```
这个的话一定要在登录后返回 `JSESSIONID` 给前端并保存在 `cookie` 中，不然的话会获取不到当前登录用户:

```
@Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        //登录成功时返回给前端的数据
        Msg result=Msg.success("登录成功！！！！！",request.getSession().getId());
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write(gson.toJson(result));
    }
```

以下方法获取当前登录用户：

```
public Users getCurrentUser(Principal principal){
        String username = principal.getName();
        Users users = usersService.checkLoginName(username);
        return users;
    }
```

5.最后可以自己配置接口的权限了,有两种方式：

(1) 第一种，直接在 `SpringSecurityConfig` 中配置

```
http.authorizeRequests()
                //开放注册接口允许所有人访问
                .antMatchers("/users/register").permitAll()
                //hasAuthority 跟数据库权限保持一致【ROLE_ADMIN】而 hasRole则需要数据库中已ROLE开头
                .antMatchers("/users/*").hasAnyRole("ADMIN", "USER")
                .antMatchers("/users/queryList").hasRole("USER")
```

(2) 第二种，使用注解方式配置,注解有很多在这里我就不一一列举了

```
@PostMapping("/update")
    @PreAuthorize("hasAnyRole('ROLE_USER','ROLE_ADMIN')")
    public Map<String, Object> update(Users users) {}


    //权限注解
    //表示只有admin权限才可访问
    @Secured("ROLE_ADMIN")
    public List<Users> queryList() {
        return usersService.queryList();
    }
```


# 整合Swagger

1.导入 `swagger` 依赖

```
        <!--swagger-->
        <dependency>
            <groupId>io.swagger</groupId>
            <artifactId>swagger-annotations</artifactId>
            <version>1.5.20</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>

        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
```

2.配置 `swagger`

```
/**
 * @author jokerpan
 */
@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //配置controller对应路径
                .apis(RequestHandlerSelectors.basePackage("com.jokerpan.project.controller"))
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //标题
                .title("JokerPan-Api文档")
                //创建人
                .contact(new Contact("JokerPan", "http://120.24.168.122", "jokerpan12@163.com"))
                //描述
                .description("API文档")
                .termsOfServiceUrl("")
                .version("1.0").build();
    }

}
```

3.在 `controller` 中增加Api注解

```
@Api("用户操作Api")
public class UsersController {
    private final Logger log = LoggerFactory.getLogger(this.getClass());
}
```

```
    @ApiOperation("查询所有用户")
    public List<Users> queryList() {
        return usersService.queryList();
    }
```

4.打开页面 `http://localhost:8088/swagger-ui.html#/` 就可以访问了


# 整合RabbitMq

1.安装 `RabbitMq` ,以我的服务器 `Ubuntu  16.04 64位` 为例：

```
.由于rabbitMq需要erlang语言的支持，在安装rabbitMq之前需要安装erlang，执行命令：

apt-get install erlang-nox     # 安装erlang
erl    # 查看relang语言版本，成功执行则说明relang安装成功

.添加公钥

wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

.更新软件包

apt-get update

.安装 RabbitMQ

apt-get install rabbitmq-server  #安装成功自动启动

.查看 RabbitMq状态

systemctl status rabbitmq-server   #Active: active (running) 说明处于运行状态

# service rabbitmq-server status 用service指令也可以查看，同systemctl指令

.启动、停止、重启

service rabbitmq-server start    # 启动
service rabbitmq-server stop     # 停止
service rabbitmq-server restart  # 重启 

执行了上面的步骤，rabbitMq已经安装成功。

.启用 web端可视化操作界面，我们还需要配置Management Plugin插件

rabbitmq-plugins enable rabbitmq_management   # 启用插件
service rabbitmq-server restart    # 重启

.查看用户

rabbitmqctl list_users

.添加管理用户

rabbitmqctl add_user admin yourpassword   # 增加普通用户 [用户名：admin  密码： yourpassword]
rabbitmqctl set_user_tags admin administrator    # 给普通用户分配管理员角色

```

2.浏览器访问http:ip:15672就可以看到 `RabbitMq` 界面了，访问前记得开放 `15672` 端口