2018-2019工作总结

2019-09-15

字数统计: 11.7k字 | 阅读时长: 64分

× 文章目录

1. 1 判断一个点是否在不规则多边形内部
2. 2 聚类经纬度
3. 3 NLP分词。文章相似度
4. 4 文章分类
5. 5 Python脚本（参考）
6. 6 SQL语句-拼接SQL
7. 7 MySql导出表结构
8. 8 多数据源（只是用来作为参考）
9. 9 JWTUtil（只是用来作为参考）
10. 10 JWTFilterConfig（只是用来作为参考）
11. 11 Login（只是用来作为参考）

Author: haoransun
Wechat: SHR—97

1 判断一个点是否在不规则多边形内部

用途：
用于判断企业是否落在指定区域内

以一个点做射线，计算它与多边形边界的交点个数
奇数个：在多边形内部
偶数个：在多边形外部
推论：
如果点在多边形内部，射线第一次穿越边界一定是穿出多边形。
如果点在多边形外部，射线第一次穿越边界一定是进入多边形。

当射线穿越多边形边界的次数为偶数时，所有第偶数次（包括最后一次）穿越都是穿出，
因此所有第奇数次（包括第一次）穿越为穿入，由此可推断点在多边形外部。

当射线穿越多边形边界的次数为奇数时，所有第奇数次（包括第一次和最后一次）穿越都是穿出
由此可推断点在多边形内部。

判断难点：
点在多边形边上：点在线上，计算点与两个多边形顶点的连线斜率是否相等。
点和多边形的顶点重合：比较坐标。
射线经过多边形顶点：射线经过的点都属于射线以上的一侧
射线经过多边形的一条边：射线连续经过多边形的两个相邻顶点。

需要客户提前给出待落区域的经纬度。

射线法：（java）
代码位置：com.aliyun.fin.rebengine.manager.job.task.AnalysisRegionOfEntDataTask

/**
 * 方法1   射线法：判断某一个点(经纬度)是否在一个多边形内  奇数个交点证明在多边形内部，偶数个交点在多边形外部
 * @param longitude
 * @param latitude
 * @param points
 * @return
 */
public boolean judgeDom(Double longitude,Double latitude,List<AreaPoint> points) {
    int iSum, iCount, iIndex;
    double dLon1 = 0, dLon2 = 0, dLat1 = 0, dLat2 = 0, dLon;
    iSum=0;
    iCount = points.size();
    for(iIndex = 0;iIndex<iCount;iIndex++){
        if(iIndex == iCount-1){
            dLon1 = points.get(iIndex).getLongitude();
            dLat1 = points.get(iIndex).getLatitude();
            dLon2 = points.get(0).getLongitude();
            dLat2 = points.get(0).getLatitude();
        }else{
            dLon1 = points.get(iIndex).getLongitude();
            dLat1 = points.get(iIndex).getLatitude();
            dLon2 = points.get(iIndex+1).getLongitude();
            dLat2 = points.get(iIndex+1).getLatitude();
        }
        //判断给定点的纵坐标 是否在边的两端点的水平平行线之间，在则可能有交点，继续判断交点是否在左射线上
        boolean isInArea = ((latitude>=dLat1)&&(latitude<dLat2))|| (latitude>=dLat2)&&(latitude<dLat1);
        if(isInArea){
            //因为要做分母，所以判断不能为0,
            if(Math.abs(dLat1-dLat2)>0){
                //得到给定点向左射线与边的  交点  的  经度坐标
                dLon = dLon1 - ((dLon1-dLon2)*(dLat1-latitude))/(dLat1-dLat2);
                //比较交点 经度坐标，如果交点在给定点的左侧：则当前交点是射线与边的交点
                if(dLon<longitude){
                    iSum++;
                }
            }
        }
    }
    if((iSum%BASE_EVEN)!=0){
        return true;
    }
    return false;
}

/**

方法2 判断某一个点(经纬度)是否在一个多边形内点在线内、线外、线上、面内、面外来进行多层判断
@param longitude
@param latitude
@param points
@return
/

public boolean judgeDom2(Double longitude,Double latitude,List<AreaPoint> points) {

    boolean flag = false;



    for(int i=0, l=points.size(),j=l-1;i<l;j=i,i++){

        double sx = points.get(i).getLongitude();

        double sy = points.get(i).getLatitude();

        double tx = points.get(j).getLongitude();

        double ty = points.get(j).getLatitude();

        //点与多边形顶点重合

        boolean isCoincide = (sx==longitude&&sy==latitude)||(tx==longitude&&ty==latitude);

        if(isCoincide){

            return true;

        }

        //判断线段两端点是否在射线两侧

        boolean isTwoSide = (sy<latitude&&ty>=latitude)||(sy>=latitude&&ty<latitude);

        if(isTwoSide){

            // 线段上与坐标 Y 相同的 点 X 的坐标

            double x = sx+(latitude-sy)*(tx-sx)/(ty-sy);

            //点在多边形边上

            if(x==longitude){

                return true;

            }

            //射线穿过多边形边界

            if(x>longitude){

                flag = !flag;

            }

        }

    }

    return  flag?true:false;

}

2 聚类经纬度

聚类经纬度数据（全景洞察-全景概览五角星、实心圆）
从reb_ent_location中取出经纬度、企业信息等数据。

企业经纬度各分10等份（汇总各个区域的最大最小值）。
分别统计出企业经纬度的最大最小值。

等分公式：对经纬度的最大最小值分别计算
Quadrant: (minLongitude,minLatitude)—à (maxLongitude,maxLatitude)
在逻辑上勾画出一个象限经纬系。

勾画出10等份区域：[(max-min)/10]*i+min i: 0-10

投射每一个企业对应的经纬度落在所画区域上
min + |(当前企业经度-min)/(max-min)/10|(max-min)/10
min + |(当前企业维度-min)/(max-min)/10)|(max-min)/10

| | ：是对其中的数据向下取整

返回100个左右的点，每一个点所对应的坐标是它周围点的坐标均值。
即：每一个点都可以想象成是一个 “黑洞”，吸收它附近的相近点
页面上：每一个点都有它所对应的企业列表集合。

代码位置：com.aliyun.fin.rebengine.manager.job.task.ClusterEntLocationDataTask

3 NLP分词。文章相似度

NLP分词、政策相似度判断
（依托于 hanlp jar包，具体用法靠参考官网 https://github.com/hankcs/HanLP）
A：政策关键词 + 政策重合度（onecompany提供政策数据）
B：热词云 + 舆情数据[公司品牌+企业高管…]（onecompany提供舆情数据）
C：自建停分词词典（需要积累）+ 客户自定义词词典。
D：舆情数据需要进行：公司品牌+企业高管+产品品质+服务质量+其他风险的摘选。

舆情分词分模块难点：
停分词词典需要积累数据，每天都会有新的舆情数据进来，会有新的热词产生，同时也需要追加新的停分词到词典中。（目前是每次对新舆情数据分词，人工过滤掉无意义词）
如何分辨当条舆情数据是当前所属公司的哪一类的舆情：（高管、品牌、产品、质量）（产品品质与服务质量没有明显的区分度）
特征词数据表：
reb_data_db-àpublic_custom (舆情分类特征词样本太少，目标区分度不明显)
读取舆情正文+标题，只要正文中出现特征词，就将当前舆情分类。
政策相似度判断：（即：政策分词后的词列表A 与词列表B 相似度分值）
相似度算法位置： com.aliyun.fin.rebengine.nlp.util.algorithm
两两地区的政策进行相似度判断。需要自己进行阈值的调参。

4 文章分类

政策分类、扶持对象
临港项目： onecompany 对政策进行分类+扶持对象的判别。

非临港项目：可能需要自己训练一个政策分类器。此处写自己的思路：
利用分布式爬虫框架从网上抓取各省市县以往的各项政策，需要抓取的内容包含：
政策标题+政策正文+该项政策的分类（金融、农业、工业..等）+政策扶持对象。

利用已有的这些数据 “喂养” 自己的分类器，（我个人觉得这不是一个线性问题，不是二分逻辑[0/1的问题]，是一个多分类问题，可能需要算法同学在隐藏层的激活函数设置的极好。[说的话都会说，关键在实现] ）
训练好分类器之后，就可以对现有的政策进行判别。

或者像舆情分模块一样：生硬的将政策分类的特征词、政策扶持对象的特征词提取到表中：只要待判别的政策正文中出现了这些特征词，就给当前政策打上分类标记、扶持对象标记。

5 Python脚本（参考）

python脚本（只是用来作为参考）


#!usr/bin/env python3
# -*- coding:utf-8 -*-
import re
import pymysql
import pandas as pd
import numpy as  np
import json

#数据库配置
mysql_config = {
    # 规则中心
    'rule': {
        'host': 'xxx',
        'port': 3306,
        'user': 'xx',
        'passwd': 'xx',
        'db': 'xx',
        'charset': 'utf8'
    },
    # 数据来源
    'data': {
        'host': 'xxx1',
        'port': 3306,
        'user': 'xxx',
        'passwd': 'xxx',
        'db': 'xxx',
        'charset': 'utf8'
    },
}


# 数据处理类
class DataDict:
    def __init__(self):
        # 最值数据的枚举KEY
        self._max_min = 'max_min'
        self._conn_rule = pymysql.connect(**mysql_config['rule'])
        self._conn_data = pymysql.connect(**mysql_config['data'])

    # DataFrame转换字典
    def _get_data_dict(self, v):
        if len(v) == 1:
            return {col: None if v.iloc[0][col] == np.nan else v.iloc[0][col] for col in v.columns}
        elif not v.empty and len(v) > 1:
            min_max = {}
            for row in v.iterrows():
                temp = {col: row[1][col] for col in v.columns}
                min_max[temp['index_name']] = temp
                min_max[temp['index_name']].pop('id')
                min_max[temp['index_name']].pop('index_name')
            min_max_temp = {}
            for key in min_max.keys():
                min_max_temp.update({
                    'min_' + key: min_max[key].get('min_value'),
                    'max_' + key: min_max[key].get('max_value'),
                })
            return min_max_temp
        elif v.empty and len(v) <= 0:
            return None
            # return {col: 0.0 if v.empty else v.iloc[0][col] for col in v.columns}
        return None

    # 最值数据获取（用于归一化处理）
    def _get_min_max_data(self, conn_data, sql_max_min):
        _v = pd.read_sql_query(sql_max_min, con=conn_data)
        _v.fillna(0, inplace=True)
        return self._get_data_dict(_v)

    # 获取评分项处理后的数据
    def get_process_data(self, ent_name):
        data_dict = dict()
        rts = dict()
        _s = pd.read_sql_query("SELECT * FROM data_config ", con=self._conn_rule)
        _s.set_index(['index'], inplace=True)
        raw_sqls = _s.to_dict()['index_sql']
        for k in raw_sqls:
            if k in self._max_min:
                data_dict['min_max'] = self._get_min_max_data(self._conn_data, raw_sqls[self._max_min])
            else:
                if '%' in raw_sqls[k]:
                    raw_sqls[k] = raw_sqls[k].replace("%", "%%")
                sql = raw_sqls[k].replace('{ent_name}', '%(ent_name)s')
                _v = pd.read_sql(sql, params={'ent_name': ent_name}, con=self._conn_data)
                # _v.fillna(0, inplace=True)
                rts[k] = self._get_data_dict(_v)
        for k in rts:
            if rts[k] is not None:
                data_dict.update(rts[k])
        return data_dict

    # 评分卡数据
    def get_score_card(self):
        sql = '''
        SELECT
   A.score_name,
   A.default_value,
   B.express,
   B.score_value,
   B.default_score
FROM
   base_score_card A,
   base_score_card_item B
WHERE
   A.id = B.card_id
ORDER BY
   A.id, B.order_no DESC
        '''
        score_card_df = pd.read_sql_query(sql, self._conn_rule)
        score_card_df_dict = dict(list(score_card_df.groupby(['score_name'])))
        score_card = {}
        for k in score_card_df_dict:
            score_card[k] = []
            for index, row in score_card_df_dict[k].iterrows():
                score_card[k].append((row['express'], row['score_value'], row['default_value'], row['default_score']))
        return score_card

    # 获取自定义公式分数节点
    def get_score_node(self):
        _dim_score_define_df = pd.read_sql_query('SELECT * FROM model_score_node', con=self._conn_rule)
        sn_dict = {}
        for index, row in _dim_score_define_df.iterrows():
            sn_dict[row['score_node_id']] = row['expression']
        return sn_dict

    # 获取分数层级数据字典
    def get_socre_level(self):
        _dim_score_define_df = pd.read_sql_query('SELECT * FROM dimensional_score_define', con=self._conn_rule)
        level_dict = {}
        for index, row in _dim_score_define_df.iterrows():
            level_dict[row['node_name']] = {col: row[col] for col in _dim_score_define_df.columns}
        return level_dict

    def close_all_conn(self):
        self._conn_rule.close()
        self._conn_data.close()

# 规则执行器
class RuleExecutor:
    def __init__(self, ent_name):
        data_dict = DataDict()
        self._original_data_dict = data_dict.get_process_data(ent_name)
        self._score_card = data_dict.get_score_card()
        self._sn_dict = data_dict.get_score_node()
        self._level_dict = data_dict.get_socre_level()
        self._tree_node = {}
        self._temp = []
        self._re_pattern = r'(?<=\{)[^}]*(?=\})'
        self._result_dict = {}
        data_dict.close_all_conn()

    def _add_node(self, p, node):
        # 节点list
        p["children"] = []
        for n in node:
            if n.get("pid") == p.get("id"):
                p["children"].append(n)
        # 递归子节点，查找子节点的子节点
        for t in p["children"]:
            if not t.get("children"):
                t["children"] = []
            t["children"].append(self._add_node(t, node))
        # 退出递归的条件
        if len(p["children"]) == 0:
            return

    def init_score_tree(self):
        root = []
        node = []
        # 获取根节点 和 其他子节点 list
        for k in self._level_dict:
            if self._level_dict[k]['pid'] == 0:
                root.append(self._level_dict[k])
            else:
                node.append(self._level_dict[k])
        # 查找子节点
        for p in root:
            self._add_node(p, node)
        self._tree_node.update(root[0])

    def _get_card_score(self, sn_id):
        score_list = self._score_card[sn_id]

        for bds in score_list:
            express = bds[0]
            score_value = bds[1]
            default_value = None if np.isnan(bds[2]) else bds[2]
            default_score = None if np.isnan(bds[3]) else bds[3]

            str_list = re.findall(self._re_pattern, express)
            str_list = list(set(str_list))
            _data_dict = {}
            for c in str_list:
                if c not in self._original_data_dict:
                    return 0
                _data_dict[c] = default_score if self._original_data_dict[c] is None  else self._original_data_dict[c]
            express_replaced = express.format(**_data_dict)

            try:
                if eval(express_replaced):
                    if '{' in score_value:
                        sv_express = score_value.format(**self._original_data_dict)
                        score_value = float(eval(sv_express))
                        score_value = score_value if score_value != 0 else abs(score_value)
                    break
            except BaseException:
                return default_value
        return float(score_value)

    # 执行sn表达式
    def _get_sn_express_value(self, sn_id):
        sn_node_express = self._sn_dict[sn_id]
        str_list = re.findall(self._re_pattern, sn_node_express)
        v_dict = {}
        for new_sn_id in str_list:
            if new_sn_id in self._sn_dict.keys():
                v_dict[new_sn_id] = self._get_sn_express_value(new_sn_id)
            else:
                card_score = self._get_card_score(new_sn_id)
                v_dict[new_sn_id] = card_score
        score = eval(sn_node_express.format(**v_dict))
        # print("sn_id:%s,  %s    %s = %s" % (sn_id, sn_node_express, sn_node_express.format(**v_dict) ,score))
        return score

    # 执行dimensional_score_define的表达式
    def _get_expression_value(self, node_name, level_dict):
        self._temp.append(node_name)

        item = level_dict[node_name]

        if item['expression'] is None or item['expression'] == '':
            sn_id = item['sn_id']
            score = self._get_sn_express_value(sn_id)
            score_info = (item['formula_id'], score)
            self._result_dict[node_name] = {'formula_id': item['formula_id'], 'value': score_info[1],
                                            'dis_name': item['node_display_name']}
            return score_info
        else:
            expression = item['expression']
            str_list = re.findall(self._re_pattern, expression)
            v_dict = {}
            for var in str_list:
                v_dict[var] = self._get_expression_value(var, level_dict)[1]
            score = eval(expression.format(**v_dict))

            score_info = (item['formula_id'], score)
            self._result_dict[node_name] = {'formula_id': item['formula_id'], 'value': score_info[1],
                                            'dis_name': item['node_display_name']}
            return score_info

    def _computer_node_score(self, tree_node={}):
        if tree_node['node_name'] in self._temp:
            return

        dis_name = tree_node['node_display_name']
        expression = tree_node['expression']
        result = {"name": dis_name, 'score': 0}
        if expression is None:
            sn_id = tree_node['sn_id']
            score = self._get_sn_express_value(sn_id)
            result['score'] = score
        else:
            str_list = re.findall(self._re_pattern, expression)
            v_dict = {}
            for score_id in str_list:
                score_info = self._get_expression_value(score_id, self._level_dict)
                score = score_info[1]
                v_dict[score_id] = score
            total_score = eval(expression.format(**v_dict))
            result['score'] = total_score
        self._result_dict[tree_node['node_name']] = {'formula_id': tree_node['formula_id'], 'value': result['score'],
                                                     'dis_name': tree_node['node_display_name']}

    def _computer_score(self, tree_node):
        children = tree_node['children']
        self._computer_node_score(tree_node)
        if len(children) == 0:
            return
        for child_node in children:
            self._computer_score(child_node)

    def process_score(self):
        self._computer_score(self._tree_node)

    def _get_standard_score(self, value, fid, df_value=0):
        min_score = self._original_data_dict['min_max']['min_' + fid]
        max_score = self._original_data_dict['min_max']['max_' + fid]
        std_score = df_value if max_score - min_score == 0 else pow((value - min_score) / (max_score - min_score), 2) * 100
        # print( 'fid:%s \t (%s - %s) / (%s - %s ) x2 * 100 = %s' % (fid,value,min_score,max_score,min_score,std_score))
        return std_score

    def _rebuild_node_tree(self, tree_node):
        for v in ['id', 'model_id', 'pid', 'default_value', 'expression', 'sn_id', 'formula_id']:
            tree_node.pop(v)
        tree_node['score'] = self._get_standard_score(self._result_dict[tree_node['node_name']]['value'],
                                                      self._result_dict[tree_node['node_name']]['formula_id'])
        child_node = tree_node['children']
        if len(child_node) > 0:
            for node in child_node:
                self._rebuild_node_tree(node)
        else:
            tree_node.pop('children')
        return tree_node

    def get_result(self):
        return self._rebuild_node_tree(self._tree_node)

    def print_data(self):
        print(self._level_dict)



def init(context):
    pass


def calc_ent(ent_info, context):

    rule_executor = RuleExecutor(ent_info["ent_name"])

    # 初始化层级树
    rule_executor.init_score_tree()

    # 计算处理
    rule_executor.process_score()

    # 获取结果
    result = rule_executor.get_result()

    return json.dumps(result,ensure_ascii= False)

if __name__ == '__main__':
    ent_info = calc_ent({"ent_name":"东方成安资产管理有限公司"},None)
    print(ent_info)

6 SQL语句-拼接SQL

select TABLE_NAME,
concat( 'insert into ', table_name, '(', GROUP_CONCAT(COLUMN_NAME) , ') select ', GROUP_CONCAT(COLUMN_NAME),
'from reb_lingang_db.', TABLE_NAME,';')
from information_schema.columns where table_schema = 'reb_lingang_db' and table_name regexp '^dw_bc*' and COLUMN_NAME not in ('id')
GROUP BY TABLE_NAME;

7 MySql导出表结构

SELECT
COLUMN_NAME 字段,
COLUMN_TYPE 数据类型,
DATA_TYPE 字段类型,
CHARACTER_MAXIMUM_LENGTH 长度,
IS_NULLABLE 是否为空,
COLUMN_KEY 是否为主键,
COLUMN_DEFAULT 默认值,
COLUMN_COMMENT 备注
FROM
INFORMATION_SCHEMA.COLUMNS
where
-- database为数据库名称，到时候只需要修改成你要导出表结构的数据库即可
table_schema ='reb_db'
AND
-- table_name为表名
table_name = 'reb_overview_comp_index_month';

8 多数据源（只是用来作为参考）


@Configuration
@MapperScan(basePackages = EngineDataSourceConfig.PACKAGE, sqlSessionFactoryRef = "engineSqlSessionFactory")
public class EngineDataSourceConfig {

    static final String PACKAGE = "com.aliyun.fin.rebengine.manager.mapper.engine";

    @Bean(name = "engineDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.engine")
    @Primary
    public DataSource engineDatasource() {
        return DataSourceBuilder.create().type(DruidDataSource.class).build();
    }

    @Bean(name = "engineSqlSessionFactory")
    @Primary
    public SqlSessionFactory engineSqlSessionFactory(@Qualifier("engineDatasource") DataSource dataSource)
        throws Exception {
        final SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //指定mapper.xml路径
        bean.setMapperLocations(
            new PathMatchingResourcePatternResolver().getResources("classpath:mapper/engine/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "engineTransactionManager")
    @Primary
    public DataSourceTransactionManager engineTransactionManager(@Qualifier("engineDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "engineSqlSessionTemplate")
    @Primary
    public SqlSessionTemplate engineSqlSessionTemplate(
        @Qualifier("engineSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean(name = "engineJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(@Qualifier("engineDatasource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}


@Configuration
@MapperScan(basePackages = RebDataSourceConfig.PACKAGE,sqlSessionFactoryRef = "rebSqlSessionFactory")
public class RebDataSourceConfig {

    static final String PACKAGE = "com.aliyun.fin.rebengine.manager.mapper.reb";

    @Bean(name = "rebDatasource")
    @ConfigurationProperties(prefix = "spring.datasource.reb")
    public DataSource rebDatasource() {
        DataSource dataSource = DataSourceBuilder.create().type(DruidDataSource.class).build();
        return dataSource;
    }

    @Bean(name = "rebSqlSessionFactory")
    public SqlSessionFactory rebSqlSessionFactory(@Qualifier("rebDatasource") DataSource dataSource) throws Exception {
        final SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //指定mapper.xml路径
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/reb/*.xml"));
        return bean.getObject();
    }

    @Bean(name = "rebTransactionManager")
    public DataSourceTransactionManager rebTransactionManager(@Qualifier("rebDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "rebSqlSessionTemplate")
    public SqlSessionTemplate rebSqlSessionTemplate(@Qualifier("rebSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean(name = "rebJdbcTemplate")
    public JdbcTemplate primaryJdbcTemplate(@Qualifier("rebDatasource") DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    reb:
      url: jdbc:mysql://127.0.0.1:3306/reb_lingang_db?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&zeroDateTimeBehavior=convertToNull&rewriteBatchedStatements=true
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
    engine:
      url: jdbc:mysql://127.0.0.1:3306/reb_data_db?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false&zeroDateTimeBehavior=convertToNull&rewriteBatchedStatements=true
      username: root
      password: 123456
      driver-class-name: com.mysql.jdbc.Driver
  thymeleaf:
     cache: false
     encoding: utf-8
     mode: HTML5
     servlet:
       content-type: text/html
server:
  port: 8081

# 日志配置
logging:
  level:
    org:
      springframework:
        web: info
        transaction: info
    com:
      aliyun:
        fin:
          rebengine:
              manager:
                mapper: error

9 JWTUtil（只是用来作为参考）

public class JwtUtil {
    /**过期时间30分钟*/
    private static final long EXPIRE_TIME = -1;

    /**
     * 生成签名(生成token字符串)
     * @param username 用户名
     * @param secret 密码
     * @return
     */
    public static String sign(String username, String secret){
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            return JWT.create()
                    .withClaim("username", username)
                    .sign(algorithm);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获得token中的信息无需secret解密也能获得
     * @return token中包含的用户名
     */
    public static String getUsername(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("username").asString();
        } catch (JWTDecodeException e) {
            return null;
        }
    }

    /**
     * 校验token是否正确
     * @param token 密钥
     * @param secret 用户的密码
     * @return 是否正确
     */
    public static boolean verify(String token, String username, String secret) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(secret);
            JWTVerifier verifier = JWT.require(algorithm)
                    .withClaim("username", username)
                    .build();
            DecodedJWT jwt = verifier.verify(token);
            return true;
        } catch (Exception exception) {
            return false;
        }
    }
}

10 JWTFilterConfig（只是用来作为参考）

@SuppressWarnings("all")
public class JWTFilterConfig implements Filter{

    @Autowired
    private RedisTemplate redisTemplate;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) servletRequest;
        HttpServletResponse httpResponse = (HttpServletResponse) servletResponse;
        String url = httpRequest.getRequestURI().substring(httpRequest.getContextPath().length());
        ServletContext sc = httpRequest.getServletContext();
        WebApplicationContext cxt = WebApplicationContextUtils.getWebApplicationContext(sc);
        if(cxt != null && cxt.getBean("redisTemplate") != null && redisTemplate == null) {
            redisTemplate = (RedisTemplate) cxt.getBean("redisTemplate");
        }
        /**
         * 跨域请求
         */
        httpResponse.setHeader("Access-Control-Allow-Origin", httpRequest.getHeader("Origin"));
//        httpResponse.setHeader("Access-Control-Expose-Headers","Content-Disposition");
        httpResponse.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, PUT, DELETE");
        httpResponse.setHeader("Access-Control-Max-Age", "3600");
        httpResponse.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, Depth, User-Agent, X-File-Size, X-Requested-With, X-Requested-By, If-Modified-Since, X-File-Name, X-File-Type, Cache-Control, Origin");
        //是否支持cookie跨域
        httpResponse.setHeader("Access-Control-Allow-Credentials","true");
        //允许在请求头里存放token
        httpResponse.setHeader("Access-Control-Expose-Headers","Authorization,Content-Disposition");

        String method = httpRequest.getMethod();
//        filterChain.doFilter(httpRequest, httpResponse);

        if ("OPTIONS".equals(method)) {
            filterChain.doFilter(httpRequest, httpResponse);
        }else{
            String authorization = httpRequest.getHeader("Authorization");
            //不需要拦截的路径
            if (!url.contains("/swagger") && !url.contains("/login") && !url.contains("/registerDepartmentSelected") &&
                    !url.contains("/getSecurityCode") && !url.contains("/register") && !url.contains("/downLoadExcel") &&
                    !url.contains("/exportEntRelation") && !url.contains("/exportCompanyList") && !url.contains("/api/merchantsradar") &&
                    !url.contains(".ico") && !url.contains(".json") && !url.contains("/statics") && !url.contains(".js") && !url.contains(".css") && !url.contains("/static") && !url.contains("/media") && !url.contains("/synchronization")) {
                if (StringUtils.isNotBlank(authorization)){
                    try {
                        String token = "";

                        //避免redis为空报错，先一步校验key是否存在
                        Boolean aBoolean = redisTemplate.hasKey("reb_backend_" + authorization);
                        if (!aBoolean){
                            JSONObject jsonObject = new JSONObject();
                            jsonObject.put("errCode", 6001);
                            jsonObject.put("errMsg", "error");
                            jsonObject.put("data", "Roles have no access rights");
                            httpResponse.setStatus(200);
                            httpResponse.setCharacterEncoding("UTF-8");
                            httpResponse.getWriter().write(JSON.toJSONString(jsonObject));
                            return;
                        }else{
                            token = redisTemplate.opsForValue().get("reb_backend_" + authorization).toString();
                        }
                        if (StringUtils.isNotBlank(token)) {
                            redisTemplate.opsForValue().set("reb_backend_" + authorization, authorization, TokenUtil.getToken(), TimeUnit.SECONDS);
                        } else {
                            JSONObject jsonObject = new JSONObject();
                            jsonObject.put("errCode", 6001);
                            jsonObject.put("errMsg", "error");
                            jsonObject.put("data", "Roles have no access rights");
                            httpResponse.setStatus(200);
                            httpResponse.setCharacterEncoding("UTF-8");
                            httpResponse.getWriter().write(JSON.toJSONString(jsonObject));
                            return;
                        }
                    }catch (Exception e){
                        JSONObject jsonObject = new JSONObject();
                        jsonObject.put("errCode", 6001);
                        jsonObject.put("errMsg", "error");
                        jsonObject.put("data", "Roles have no access rights");
                        httpResponse.setStatus(200);
                        httpResponse.setCharacterEncoding("UTF-8");
                        httpResponse.getWriter().write(JSON.toJSONString(jsonObject));
                        return;
                    }
                }else{
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("errCode", 6001);
                    jsonObject.put("errMsg", "error");
                    jsonObject.put("data", "Roles have no access rights");
                    httpResponse.setStatus(200);
                    httpResponse.setCharacterEncoding("UTF-8");
                    httpResponse.getWriter().write(JSON.toJSONString(jsonObject));
                    return;
                }
            }
            filterChain.doFilter(httpRequest, httpResponse);
        }
    }

    @Override
    public void destroy() {

    }
}

@RequestMapping("user")
@RestController
@Api(tags = {"后台管理"})
public class UserController {

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


    @Autowired
    private UserService userService;

    @Autowired
    private RedisTemplate redisTemplate;

    @Value("${spring.rebBackend.token.expirationDate}")
    private long tokenExpirationDate;

    /**
      * @Description: 用户管理-用户登录
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/10/10 18:12
    **/
    @ApiOperation("用户管理-用户登录")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "account",value = "用户账号",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "password",value = "用户密码",paramType = "query",dataType = "String")
    })
    @GetMapping("/login")
    public JSONObject login(String account, String password,HttpServletRequest request){
        JSONObject jsonObject = new JSONObject();
        try {
            if(StringUtils.isBlank(password) ){
                jsonObject.put("errorCode",ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","password" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(account)){
                jsonObject.put("errorCode",ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","account" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            String userStatus = (String) redisTemplate.opsForValue().get("reb_backend_" + account);
            String index = "3";
            if (StringUtils.equals(userStatus,index)){
                jsonObject.put("errorCode",ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","密码错误次数过多,请5分钟之后重试");
                return jsonObject;
            }
            //校验账户是否存在
            User user = userService.findUserByAccount(account);
            if (null==user){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","账户不存在");
                return jsonObject;
            }
            String index2 = "2";
            if (user.getStatus().equals(index2)){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","账户已被锁定");
                return jsonObject;
            }
            String index3 = "3";
            if (user.getStatus().equals(index3)){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","账户正在审批中");
                return jsonObject;
            }
            String md5Password = PasswordUtil.encode(password,"fin_risk_management_reb_backend");
            if (user.getPassword().equals(md5Password)){
                //登录成功之后保存用户操作日志
                UserLogger userLogger = new UserLogger(){{
                    setUserAccount(account);
                    setUserName(user.getUsername());
                    setLoggerType("1");
                }};
                userService.saveUserLogger(userLogger);
                //登录成功之后将token缓存到redis
                String token = JwtUtil.sign(account,user.getPassword());
                RedisModel redisModel = new RedisModel(){{
                    setKey("reb_backend_" + token);
                    setValue(token);
                }};
                redisTemplate.opsForValue().set(redisModel.getKey(),redisModel.getValue(),tokenExpirationDate,TimeUnit.SECONDS);
                jsonObject.put("token",token);
                jsonObject.put("username",user.getUsername());
                jsonObject.put("userId",user.getId());
                List<String> roleList = userService.findRoleListByUserId(user.getId());
                //获取用户所属部门
                Integer departmentId = userService.findDepartmentIdByUserId(user.getId());
                jsonObject.put("role",roleList.get(0));
                jsonObject.put("departmentId",departmentId);
                jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
                jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            }else{
                userStatus = userStatus==null ? "1" : Integer.parseInt(userStatus)  + 1 + "";

                if (userStatus.equals(index3)){
                    redisTemplate.opsForValue().set("reb_backend_" + user.getAccount(),userStatus,300, TimeUnit.SECONDS);
                }else{
                    redisTemplate.opsForValue().set("reb_backend_" + user.getAccount(),userStatus,300,TimeUnit.SECONDS);
                }
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","密码错误");
            }
        } catch (Exception e) {
            e.printStackTrace();
            logger.error("用户管理-用户登录===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
            return jsonObject;
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-登出接口
      * @return com.alibaba.fastjson.JSONObject
      * @date 2019/1/23 11:12
    **/
    @GetMapping("exit")
    @ApiOperation("用户管理-登出接口")
    public JSONObject exit(@RequestHeader("Authorization") String token){
        JSONObject jsonObject = new JSONObject();
        try {
            redisTemplate.delete("reb_backend_" + token);
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            userService.exit(user);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-登出接口===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
            return jsonObject;
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-用户注册
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/11/20 10:05
    **/
    @ApiOperation("用户管理-用户注册")
    @GetMapping("register")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "password",value = "用户密码",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "username",value = "用户名",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "departmentId",value = "部门ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "phone",value = "手机号",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "code",value = "验证码",paramType = "query",dataType = "String")
    })
    public JSONObject register(String username,String phone,Integer departmentId,String password,String code,HttpServletRequest request) {
        JSONObject jsonObject = new JSONObject();
        String checkCode = (String) request.getSession().getAttribute("code");
        String newCheckCode = checkCode.toLowerCase();
        String newCode = code.toLowerCase();
        if (!newCode.equals(newCheckCode)) {
            jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
            jsonObject.put("errorMsg", "验证码错误");
            return jsonObject;
        }
        if (StringUtils.isBlank(username)) {
            jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
            jsonObject.put("errorMsg", "username" + ResponseCode.MSG_PARAM_NULL);
            return jsonObject;
        }
        if (StringUtils.isBlank(phone)) {
            jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
            jsonObject.put("errorMsg", "phone" + ResponseCode.MSG_PARAM_NULL);
            return jsonObject;
        }
        if (StringUtils.isBlank(password)) {
            jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
            jsonObject.put("errorMsg", "password" + ResponseCode.MSG_PARAM_NULL);
            return jsonObject;
        }
        //校验账户是否存在
        User user = userService.findUserByAccount(phone);
        if (user != null) {
            jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
            jsonObject.put("errorMsg", "该手机号已被注册");
            return jsonObject;
        }
        try {
            String md5Password = PasswordUtil.encode(password, "fin_risk_management_reb_backend");
            userService.register(username, phone, departmentId, md5Password);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg", ResponseCode.MSG_SUCCESS);
        } catch (Exception e) {
            logger.error("用户管理-用户注册===", e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg", ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 后台管理-用户登录首次加载列表
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/10 13:53
    **/
    @ApiOperation("后台管理-用户登录首次加载列表")
    @GetMapping("userLoginFirstLoadList")
    public JSONObject userLoginFirstLoadList(@RequestHeader("Authorization") String token){
        JSONObject jsonObject = new JSONObject();
        try {
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            List<String> roleList = userService.findRoleListByUserId(user.getId());
            jsonObject = userService.userLoginFirstLoadList(roleList.get(0),user.getId());
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("后台管理-用户登录首次加载列表===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 部门管理-模块授权下拉
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/11 16:10
    **/
    @ApiOperation("部门管理-模块授权下拉框")
    @GetMapping("authorizationModuleSelected")
    public JSONObject authorizationModuleSelected(){
        JSONObject jsonObject = new JSONObject();
        try {
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            jsonObject = userService.authorizationModuleSelected();
        }catch (Exception e){
            logger.error("部门管理-模块授权下拉框===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-用户列表展示
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/12 10:55
    **/
    @ApiOperation("用户管理-用户列表展示")
    @GetMapping("readUserListShow")
    public JSONObject readUserListShow(@RequestHeader("Authorization") String token){
        JSONObject jsonObject = new JSONObject();
        try {
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            List<String> roleList = userService.findRoleListByUserId(user.getId());
            List<UserVO> list = userService.readUserListShow(roleList.get(0),user.getId());
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            jsonObject.put("data",list);
        }catch (Exception e){
            logger.error("用户管理-用户列表展示===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-角色下拉框
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/13 10:06
    **/
    @ApiOperation("用户管理-角色下拉框")
    @GetMapping("readRoleSelected")
    public JSONObject readRoleSelected(@RequestHeader("Authorization") String token){
        JSONObject jsonObject = new JSONObject();
        try {
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            List<String> roleList = userService.findRoleListByUserId(user.getId());
            JSONArray jsonArray = userService.readRoleSelected(roleList.get(0));
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            jsonObject.put("data",jsonArray);
        }catch (Exception e){
            logger.error("用户管理-角色下拉框===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-账号删除/拒绝通用接口
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/13 11:26
    **/
    @ApiOperation("用户管理-账号删除/拒绝通用接口")
    @GetMapping("delAndRefuseUser")
    @ApiImplicitParam(name = "userId",value = "用户ID",paramType = "query",dataType = "Integer")
    public JSONObject delAndRefuseUser(Integer userId){
        JSONObject jsonObject = new JSONObject();
        try {
            userService.delAndRefuseUser(userId);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-账号删除/拒绝通用接口===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-账号启用/禁用通用接口
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/13 11:43
    **/
    @ApiOperation("用户管理-账号启用/禁用通用接口")
    @GetMapping("enableAndDisabledUser")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId",value = "用户ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "userStatus",value = "用户状态 1：启用 2：禁用 3：申请中",paramType = "query",dataType = "Integer")
    })
    public JSONObject enableAndDisabledUser(Integer userId,Integer userStatus){
        JSONObject jsonObject = new JSONObject();
        try {
            userService.enableAndDisabledUser(userId,userStatus);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-账号启用/禁用通用接口===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-用户通过申请
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/13 14:41
    **/
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId",value = "用户ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "roleId",value = "角色ID",paramType = "query",dataType = "Integer")
    })
    @ApiOperation("用户管理-用户通过申请")
    @GetMapping("adoptUser")
    public JSONObject adoptUser(Integer userId,Integer roleId){
        JSONObject jsonObject = new JSONObject();
        try {
            userService.adoptUser(userId,roleId);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-用户通过申请===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-管理员添加用户
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/14 17:08
    **/
    @ApiOperation("用户管理-管理员添加用户")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "username",value = "用户名",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "departmentId",value = "部门ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "phone",value = "手机号",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "roleId",value = "角色ID",paramType = "query",dataType = "Integer")
    })
    @GetMapping("adminAddUser")
    public JSONObject adminAddUser(String username,Integer departmentId,String phone,Integer roleId){
        JSONObject jsonObject = new JSONObject();
        try{
            Integer userId = userService.findUserIdByAccountAndUserId(phone,0);
            if (userId != null){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","该登录账号已存在");
                return jsonObject;
            }
            if (StringUtils.isBlank(username)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","username" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(phone)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","phone" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            userService.adminAddUser(username,departmentId,phone,roleId);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            logger.error("用户管理-管理员添加用户===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-修改用户
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/17 14:45
    **/
    @ApiOperation("用户管理-修改用户")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id",value = "用户ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "username",value = "用户名",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "departmentId",value = "部门ID",paramType = "query",dataType = "Integer"),
            @ApiImplicitParam(name = "phone",value = "手机号",paramType = "query",dataType = "String"),
            @ApiImplicitParam(name = "roleId",value = "角色ID",paramType = "query",dataType = "Integer")
    })
    @GetMapping("updateUser")
    public JSONObject updateUser(Integer id,String username,Integer departmentId,String phone,Integer roleId){
        JSONObject jsonObject = new JSONObject();
        try{
            if (StringUtils.isBlank(username)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","username" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(phone)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","phone" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            //校验手机号是否已存在
            Integer userId = userService.findUserIdByAccountAndUserId(phone,id);
            if (userId != null){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","该登录账号已存在");
                return jsonObject;
            }
            userService.updateUser(id,username,departmentId,phone,roleId);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-修改用户===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 部门管理-添加部门
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/19 10:12
    **/
    @ApiOperation("部门管理-添加部门")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "departmentName", value = "部门名称", paramType = "query", dataType = "String"),
            @ApiImplicitParam(name = "model", value = "模块JSON", paramType = "query", dataType = "String")
    })
    @GetMapping("addDepartment")
    public JSONObject addDepartment(String departmentName,String model){
        JSONObject jsonObject = new JSONObject();
        try {
            if (StringUtils.isBlank(departmentName)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","departmentName" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(model)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","model" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            //校验部门名称是否已存在
            Integer id = userService.findDepartmentByDepartmentName(departmentName);
            if (id != null){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","部门名称已存在");
                return jsonObject;
            }
            userService.addDepartment(departmentName,model);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            e.printStackTrace();
            logger.error("部门管理-添加部门===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 部门管理-部门列表展示
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/19 11:00
    **/
    @ApiOperation("部门管理-部门列表展示")
    @GetMapping("readDepartmentShow")
    public JSONObject readDepartmentShow(@RequestHeader("Authorization") String token) {
        JSONObject jsonObject = new JSONObject();
        try {
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            List<String> roleList = userService.findRoleListByUserId(user.getId());
            List<DictDepartment> list = userService.readDepartmentShow(roleList.get(0), user.getId());
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg", ResponseCode.MSG_SUCCESS);
            jsonObject.put("data", list);
        } catch (Exception e) {
            logger.error("部门管理-部门列表展示===", e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg", ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 部门管理-删除部门
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/29 9:52
    **/
    @ApiOperation("部门管理-删除部门")
    @ApiImplicitParam(name = "departmentId", value = "部门ID", paramType = "query", dataType = "Integer")
    @GetMapping("delDepartment")
    public JSONObject delDepartment(Integer departmentId){
        JSONObject jsonObject = new JSONObject();
        try {
            userService.delDepartment(departmentId);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg", ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("部门管理-删除部门===", e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg", ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 部门管理-授权模块
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/19 16:31
    **/
    @ApiOperation("部门管理-授权模块")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "departmentId", value = "部门ID", paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "model", value = "模块JSON", paramType = "query", dataType = "String")
    })
    @GetMapping("authorizationModule")
    public JSONObject authorizationModule(Integer departmentId,String model){
        JSONObject jsonObject = new JSONObject();
        try {
            userService.authorizationModule(departmentId,model);
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("部门管理-授权模块===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-部门下拉框
      * @return com.alibaba.fastjson.JSONObject
      * @date 2018/12/19 17:40
    **/
    @ApiOperation("用户管理-部门下拉框")
    @GetMapping("readDepartmentSelected")
    public JSONObject readDepartmentSelected(@RequestHeader("Authorization") String token){
        JSONObject jsonObject = new JSONObject();
        try {
            String account = JwtUtil.getUsername(token);
            //根据用户账号获取用户信息
            User user = userService.findUserByAccount(account);
            List<String> roleList = userService.findRoleListByUserId(user.getId());
            List<DictDepartment> list = userService.readDepartmentSelected(roleList.get(0),user.getId());
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            jsonObject.put("data",list);
        }catch (Exception e){
            logger.error("用户管理-部门下拉框===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
     * @Description: 用户管理-用户注册部门下拉框
     * @return com.alibaba.fastjson.JSONObject
     * @date 2018/12/19 17:40
     **/
    @ApiOperation("用户管理-用户注册部门下拉框")
    @GetMapping("registerDepartmentSelected")
    public JSONObject registerDepartmentSelected(){
        JSONObject jsonObject = new JSONObject();
        try {
            List<DictDepartment> list = userService.registerDepartmentSelected();
            jsonObject.put("errorCode", ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
            jsonObject.put("data",list);
        }catch (Exception e){
            logger.error("用户管理-用户注册部门下拉框===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-获取验证码
      * @return void
      * @date 2018/12/26 14:58
    **/
    @ApiOperation("用户管理-获取验证码")
    @RequestMapping(value = "getSecurityCode",method = RequestMethod.GET)
    public void getSecurityCode(HttpServletResponse response, HttpServletRequest request,Integer random){
        // 设置响应的类型格式为图片格式
        response.setContentType("image/jpeg");
        // 通知浏览器不要缓存
        response.setHeader("Expires", "-1");
        response.setHeader("Cache-Control", "no-cache");
        response.setHeader("Pragma", "-1");
        SecurityUtil util = SecurityUtil.instance();
        // 将验证码输入到session中，用来验证
        String code = util.getString();
        request.getSession().setAttribute("code", code);
        // 输出打web页面
        try {
            ImageIO.write(util.getImage(), "jpg", response.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
      * @Description: 用户管理-修改密码
      * @return com.alibaba.fastjson.JSONObject
      * @date 2019/1/10 14:21
    **/
    @ApiOperation("用户管理-修改密码")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId", value = "用户ID", paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "password", value = "密码", paramType = "query", dataType = "String")
    })
    @GetMapping("updatePassword")
    public JSONObject updatePassword(Integer userId,String password){
        JSONObject jsonObject = new JSONObject();
        try {
            if (userId == null){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","userId" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(password)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","password" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            userService.updatePassword(userId,password);
            jsonObject.put("errorCode",ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-修改密码===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-校验原密码是否正确
      * @return com.alibaba.fastjson.JSONObject
      * @date 2019/1/10 14:36
    **/
    @ApiOperation("用户管理-校验原密码是否正确")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userId", value = "用户ID", paramType = "query", dataType = "Integer"),
            @ApiImplicitParam(name = "password", value = "密码", paramType = "query", dataType = "String")
    })
    @GetMapping("checkPassword")
    public JSONObject checkPassword(String password,Integer userId){
        JSONObject jsonObject = new JSONObject();
        try {
            if (userId == null){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","userId" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            if (StringUtils.isBlank(password)){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","password" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            boolean check = userService.checkPassword(userId,password);
            if (!check){
                jsonObject.put("errorCode", ResponseCode.CODE_RESULT_NULL);
                jsonObject.put("errorMsg","密码错误");
                return jsonObject;
            }
            jsonObject.put("errorCode",ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-校验原密码是否正确===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }

    /**
      * @Description: 用户管理-重置密码
      * @return com.alibaba.fastjson.JSONObject
      * @date 2019/1/10 14:57
    **/
    @ApiOperation("用户管理-重置密码")
    @ApiImplicitParam(name = "userId", value = "用户ID", paramType = "query", dataType = "Integer")
    @GetMapping("resetPassword")
    public JSONObject resetPassword(Integer userId){
        JSONObject jsonObject = new JSONObject();
        try {
            if (userId == null){
                jsonObject.put("errorCode", ResponseCode.CODE_PARAM_NULL);
                jsonObject.put("errorMsg","userId" + ResponseCode.MSG_PARAM_NULL);
                return jsonObject;
            }
            userService.resetPassword(userId);
            jsonObject.put("errorCode",ResponseCode.CODE_SUCCESS);
            jsonObject.put("errorMsg",ResponseCode.MSG_SUCCESS);
        }catch (Exception e){
            logger.error("用户管理-重置密码===",e.getMessage());
            jsonObject.put("errorCode", ResponseCode.CODE_ERROR);
            jsonObject.put("errorMsg",ResponseCode.MSG_ERROR);
        }
        return jsonObject;
    }
}

12 Pom配置（只是用来作为参考）

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>reb_backend</artifactId>
        <groupId>com.aliyun</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>reb_service</artifactId>

    <name>reb_service</name>
    <!-- FIXME change it to the project's website -->
    <url>http://www.example.com</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <shiro.version>1.4.0</shiro.version>
    </properties>

    <dependencies>

        <!-- redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--Spring Boot中使用Swagger2构建强大的RESTful API文档-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.7.0</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.7.0</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!-- 连接池  -->
        <!--<dependency>-->
            <!--<groupId>com.alibaba</groupId>-->
            <!--<artifactId>druid-spring-boot-starter</artifactId>-->
            <!--<version>1.1.5</version>-->
        <!--</dependency>-->

        <!-- esay poi -->
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-web</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-annotation</artifactId>
            <version>3.0.3</version>
        </dependency>
        <!-- guava -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>

        <!-- shiro 配置-->
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-core</artifactId>
            <version>${shiro.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-web</artifactId>
            <version>${shiro.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.shiro</groupId>
            <artifactId>shiro-spring</artifactId>
            <version>${shiro.version}</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.3.0</version>
        </dependency>

        <!-- json -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>


        <!-- 缓存 -->
        <dependency>
            <groupId>net.sf.ehcache</groupId>
            <artifactId>ehcache</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>
        <dependency>
            <groupId>com.aliyun</groupId>
            <artifactId>reb_common</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.0</version>
        </dependency>

        <!--easypoi-->
        <!--easypoi导出excel -->
        <!--easypoi-base 导入导出的工具包,可以完成Excel导出,导入,Word的导出,Excel的导出功能 -->
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-web</artifactId>
            <version>3.0.3</version>
        </dependency>
        <dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-annotation</artifactId>
            <version>3.0.3</version>
        </dependency>

        <!-- springboot整合redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <!-- 指定该Main Class为全局的唯一入口 -->
                    <mainClass>com.aliyun.finintell.rebbackend.RebBackendApplication</mainClass>
                    <layout>ZIP</layout>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal><!--可以把依赖的包都打包到生成的Jar包中-->
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <pluginManagement><!-- lock down plugins versions to avoid using Maven defaults (may be moved to parent pom) -->
            <plugins>
                <plugin>
                    <artifactId>maven-clean-plugin</artifactId>
                    <version>3.0.0</version>
                </plugin>
                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_jar_packaging -->
                <plugin>
                    <artifactId>maven-resources-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.7.0</version>
                </plugin>
                <plugin>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>2.20.1</version>
                </plugin>
                <plugin>
                    <artifactId>maven-jar-plugin</artifactId>
                    <version>3.0.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-install-plugin</artifactId>
                    <version>2.5.2</version>
                </plugin>
                <plugin>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <version>2.8.2</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>

</project>