Song/xkrs_ms
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feature (办公基价迁移)： 完成办公计价迁移

Browse Source 
1. 办公案例下载
2. 办公案例清洗
3. 办公基价计算
4. 办公基价导入
5. 物业基价菜单调整
6. 住宅租赁挂牌案例下载
7. 住宅租赁案例清洗
This commit is contained in:
purple 2020-07-06 18:46:13 +08:00
parent 706dddeedd
commit 1c2e15016a
371 changed files with 25749 additions and 24484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ruoyi/Dockerfile Normal file
View File

@ -0,0 +1,15 @@
FROM 172.16.30.92:5000/uv:jdk-1.8.0
VOLUME /tmp
# 将jar包添加到容器中并更名为app.jar
ADD ./target/uv-data-backend.jar app.jar
# 创建日志目录
#RUN mkdir -p /var/log/uv-data/ /opt/sites/collateral/ /opt/sites/calc/ /opt/sites/hanlp-data/
#RUN mkdir -p /opt/sites/collateral/
# 运行jar包
#RUN bash -c 'touch /app.jar'
# -Djava.security.egd为了缩短tomcat启动时间
CMD java -Xms2048m -Xmx2048m -jar /app.jar --spring.profiles.active=prod

6
ruoyi/makefile.ps1 Normal file
View File

@ -0,0 +1,6 @@
param([string]$v=$(throw "Parameter missing: -v Version"))
docker build -t 172.16.30.243:5000/uv-data-backend:v$v .
docker push 172.16.30.243:5000/uv-data-backend:v$v

8
ruoyi/pom.xml
View File

@ -3,15 +3,11 @@
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <modelVersion>4.0.0</modelVersion>
<groupId>com.ruoyi</groupId> <groupId>com.uvaluation</groupId>
<artifactId>ruoyi</artifactId> <artifactId>uv-data-backend</artifactId>
<version>2.2.0</version> <version>2.2.0</version>
<packaging>jar</packaging> <packaging>jar</packaging>
<name>ruoyi</name>
<url>http://www.ruoyi.vip</url>
<description>若依管理系统</description>
<parent> <parent>
<groupId>org.springframework.boot</groupId> <groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId> <artifactId>spring-boot-starter-parent</artifactId>

21
ruoyi/sql/office_price.sql
View File

@ -1,24 +1,3 @@
-- create type dbo.DWA_PROJECTBASEPRICE_OFFICE_MANU_Table as table(
-- BuildingID bigint NOT NULL,
-- ProjectID bigint NULL,
-- County nvarchar (512) NULL,
-- Loop nvarchar (512) NULL,
-- Block nvarchar (512) NULL,
-- ProjectAddr nvarchar (1024) NULL,
-- ProjectName nvarchar (1024) NULL,
-- Year int NULL,
-- AvgArea decimal (18, 2) NULL,
-- TotalFloorSum nvarchar (32) NULL,
-- UpperFloorSum nvarchar (32) NULL,
-- OfficeClass nvarchar (256) NULL,
-- Grade nvarchar (64) NULL,
-- MainPrice_1 decimal (18, 2) NULL,
-- MainPriceRent_1 decimal (18, 2) NULL,
-- MainPrice decimal (18, 2) NULL,
-- MainPriceRent decimal (18, 2) NULL,
-- ModifyDate date NULL
-- )
-- go
create type dbo.DWA_PROJECTBASEPRICE_OFFICE_MANU_Table as table create type dbo.DWA_PROJECTBASEPRICE_OFFICE_MANU_Table as table
( (
BuildingID nvarchar(20) null BuildingID nvarchar(20) null

12
ruoyi/sql/rent_price.sql Normal file
View File

@ -0,0 +1,12 @@
create type [dbo].[DWA_PROJECTBASEPRICE_RENT_MANU_Table] as table(
ID int not null
, ProjectID nvarchar(32) primary key
, MainCoff_Rent decimal(7, 4)
, RentPrice decimal(18, 2)
, MainRentPrice decimal(18, 2)
, RentPrice_1 decimal(18, 2)
, VOPPAT varchar(64)
, VOPPA decimal(18, 6)
, ModifyDate date
)
go

111
ruoyi/src/main/java/com/ruoyi/project/data/cases/service/impl/OriginalResidenceRentClosingCaseServiceImpl.java
View File

@ -1,111 +0,0 @@
package com.ruoyi.project.data.cases.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.ruoyi.common.utils.LoadUtil;
import com.ruoyi.project.data.cases.domain.OriginalResidenceSaleClosingCase;
import com.ruoyi.project.data.cases.mapper.OriginalResidenceSaleClosingCaseMapper;
import com.ruoyi.project.data.cases.mapper.sync.DownloadOriginalResidenceSaleClosingCaseMapper;
import com.ruoyi.project.data.cases.service.IOriginalResidenceRentClosingCaseService;
import com.ruoyi.project.data.cases.service.IOriginalResidenceSaleClosingCaseService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
@Service
@DS("compute")
public class OriginalResidenceRentClosingCaseServiceImpl implements IOriginalResidenceRentClosingCaseService {
private static Logger logger = LoggerFactory.getLogger(OriginalResidenceRentClosingCaseServiceImpl.class);
@Autowired
private OriginalResidenceSaleClosingCaseMapper originalResidenceSaleClosingCaseMapper;
@Autowired
private DownloadOriginalResidenceSaleClosingCaseMapper downloadOriginalResidenceSaleClosingCaseMapper;
@Autowired
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
@Autowired
private JdbcTemplate jdbcTemplate;
/**
*
*/
@Scheduled(cron = "0 0 5 9 * ?")
@Override
public void pullData() {
Calendar calendar = Calendar.getInstance();
calendar.setTime(new Date());
Integer targetTableRoute = new Integer(String.format("%d%02d", calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH)));
calendar.add(Calendar.MONTH, 1);
Integer computeTableRoute = new Integer(String.format("%d%02d", calendar.get(Calendar.YEAR),
calendar.get(Calendar.MONTH) + 1));
prepare(computeTableRoute);
List<OriginalResidenceSaleClosingCase> list =
downloadOriginalResidenceSaleClosingCaseMapper.download(targetTableRoute);
list.parallelStream().forEach(originalResidenceSaleClosingCase -> {
originalResidenceSaleClosingCase.setCaseId(originalResidenceSaleClosingCase.generateCaseId());
// originalResidenceSaleClosingCase.setCleanPropertyType(originalResidenceSaleClosingCase.refinePropertyType());
// originalResidenceSaleClosingCase.setCleanCurrentFloor(originalResidenceSaleClosingCase
// .refineCurrentFloor());
// originalResidenceSaleClosingCase.setCleanBuildingAddress(originalResidenceSaleClosingCase
// .refineBuildingAddress());
});
running(computeTableRoute, list);
// after(computeTableRoute);
}
/**
* 准备工作 创建表
*
* @param computeTableRoute
*/
public void prepare(Integer computeTableRoute) {
originalResidenceSaleClosingCaseMapper.createTable(computeTableRoute);
// originalResidenceSaleClosingCaseMapper.createClosingCaseRawTable(computeTableRoute);
originalResidenceSaleClosingCaseMapper.createCleanTable(computeTableRoute);
}
/**
* 批量入库
*
* @param computeTableRoute
* @param list
*/
public void running(Integer computeTableRoute, List<OriginalResidenceSaleClosingCase> list) {
SqlParameterSource[] batchParams = SqlParameterSourceUtils.createBatch(list.toArray());
int[] updateCounts = namedParameterJdbcTemplate.batchUpdate("insert into dbo" +
".original_residence_sale_closing_case_" + computeTableRoute + "(case_id,case_county_name," +
"case_block_name,case_loopline_name,case_community_name,case_address,case_area," +
"case_unit_price,case_total_price,case_house_type,case_signing_date,case_register_date," +
"case_agency_name,case_agency_type,case_seller_type,case_buyer_type,case_birthday," +
"case_deal_type,clean_property_type,create_time) " +
"values (:caseId,:caseCountyName,:caseBlockName,:caseLoopName,:caseCommunityName," +
":caseAddress,:caseArea,:caseUnitPrice,:caseTotalPrice,:caseHouseType,:caseSigningDate," +
":caseRegisterDate,:agencyName,:agencyType,:sellerType,:buyerType,:birthday," +
":cleanCaseType,:cleanPropertyType,GETDATE());",
batchParams);
}
/**
* 匹配数据
*
* @param yearMonth
*/
public void after(Integer yearMonth) {
// 清洗挂牌案例
String rawSql = LoadUtil.loadContent("sql-template/clear_residence_sale_closing_case.sql");
String sql = rawSql.replace("#yearMonth#", yearMonth.toString());
jdbcTemplate.update(sql);
}
}

12
ruoyi/src/main/java/com/ruoyi/RuoYiApplication.java → ruoyi/src/main/java/com/uvaluation/RuoYiApplication.java
View File

@ -1,4 +1,4 @@
package com.ruoyi; package com.uvaluation;
//import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure; //import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure;
import com.github.pagehelper.autoconfigure.PageHelperAutoConfiguration; import com.github.pagehelper.autoconfigure.PageHelperAutoConfiguration;
@ -18,15 +18,5 @@ public class RuoYiApplication {
public static void main(String[] args) { public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false"); System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(RuoYiApplication.class, args); SpringApplication.run(RuoYiApplication.class, args);
System.out.println("(♥◠‿◠)ﾉﾞ 若依启动成功 ლ(´ڡ`ლ)ﾞ \n" +
" .-------. ____ __ \n" +
" | _ _ \\ \\ \\ / / \n" +
" | ( ' ) | \\ _. / ' \n" +
" |(_ o _) / _( )_ .' \n" +
" | (_,_).' __ ___(_ o _)' \n" +
" | |\\ \\ | || |(_,_)' \n" +
" | | \\ `' /| `-' / \n" +
" | | \\ / \\ / \n" +
" ''-' `'-' `-..-' ");
} }
} }

36
ruoyi/src/main/java/com/ruoyi/RuoYiServletInitializer.java → ruoyi/src/main/java/com/uvaluation/RuoYiServletInitializer.java
View File

@ -1,18 +1,18 @@
package com.ruoyi; package com.uvaluation;
import org.springframework.boot.builder.SpringApplicationBuilder; import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
/** /**
* web容器中进行部署 * web容器中进行部署
* *
* @author ruoyi * @author ruoyi
*/ */
public class RuoYiServletInitializer extends SpringBootServletInitializer public class RuoYiServletInitializer extends SpringBootServletInitializer
{ {
@Override @Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) protected SpringApplicationBuilder configure(SpringApplicationBuilder application)
{ {
return application.sources(RuoYiApplication.class); return application.sources(RuoYiApplication.class);
} }
} }

212
ruoyi/src/main/java/com/ruoyi/common/constant/Constants.java → ruoyi/src/main/java/com/uvaluation/common/constant/Constants.java
View File

@ -1,106 +1,106 @@
package com.ruoyi.common.constant; package com.uvaluation.common.constant;
import io.jsonwebtoken.Claims; import io.jsonwebtoken.Claims;
/** /**
* 通用常量信息 * 通用常量信息
* *
* @author ruoyi * @author ruoyi
*/ */
public class Constants public class Constants
{ {
/** /**
* UTF-8 字符集 * UTF-8 字符集
*/ */
public static final String UTF8 = "UTF-8"; public static final String UTF8 = "UTF-8";
/** /**
* GBK 字符集 * GBK 字符集
*/ */
public static final String GBK = "GBK"; public static final String GBK = "GBK";
/** /**
* 通用成功标识 * 通用成功标识
*/ */
public static final String SUCCESS = "0"; public static final String SUCCESS = "0";
/** /**
* 通用失败标识 * 通用失败标识
*/ */
public static final String FAIL = "1"; public static final String FAIL = "1";
/** /**
* 登录成功 * 登录成功
*/ */
public static final String LOGIN_SUCCESS = "Success"; public static final String LOGIN_SUCCESS = "Success";
/** /**
* 注销 * 注销
*/ */
public static final String LOGOUT = "Logout"; public static final String LOGOUT = "Logout";
/** /**
* 登录失败 * 登录失败
*/ */
public static final String LOGIN_FAIL = "Error"; public static final String LOGIN_FAIL = "Error";
/** /**
* 验证码 redis key * 验证码 redis key
*/ */
public static final String CAPTCHA_CODE_KEY = "captcha_codes:"; public static final String CAPTCHA_CODE_KEY = "captcha_codes:";
/** /**
* 登录用户 redis key * 登录用户 redis key
*/ */
public static final String LOGIN_TOKEN_KEY = "login_tokens:"; public static final String LOGIN_TOKEN_KEY = "login_tokens:";
/** /**
* 验证码有效期（分钟） * 验证码有效期（分钟）
*/ */
public static final Integer CAPTCHA_EXPIRATION = 2; public static final Integer CAPTCHA_EXPIRATION = 2;
/** /**
* 令牌 * 令牌
*/ */
public static final String TOKEN = "token"; public static final String TOKEN = "token";
/** /**
* 令牌前缀 * 令牌前缀
*/ */
public static final String TOKEN_PREFIX = "Bearer "; public static final String TOKEN_PREFIX = "Bearer ";
/** /**
* 令牌前缀 * 令牌前缀
*/ */
public static final String LOGIN_USER_KEY = "login_user_key"; public static final String LOGIN_USER_KEY = "login_user_key";
/** /**
* 用户ID * 用户ID
*/ */
public static final String JWT_USERID = "userid"; public static final String JWT_USERID = "userid";
/** /**
* 用户名称 * 用户名称
*/ */
public static final String JWT_USERNAME = Claims.SUBJECT; public static final String JWT_USERNAME = Claims.SUBJECT;
/** /**
* 用户头像 * 用户头像
*/ */
public static final String JWT_AVATAR = "avatar"; public static final String JWT_AVATAR = "avatar";
/** /**
* 创建时间 * 创建时间
*/ */
public static final String JWT_CREATED = "created"; public static final String JWT_CREATED = "created";
/** /**
* 用户权限 * 用户权限
*/ */
public static final String JWT_AUTHORITIES = "authorities"; public static final String JWT_AUTHORITIES = "authorities";
/** /**
* 资源映射路径 前缀 * 资源映射路径 前缀
*/ */
public static final String RESOURCE_PREFIX = "/profile"; public static final String RESOURCE_PREFIX = "/profile";
} }

188
ruoyi/src/main/java/com/ruoyi/common/constant/GenConstants.java → ruoyi/src/main/java/com/uvaluation/common/constant/GenConstants.java
View File

@ -1,94 +1,94 @@
package com.ruoyi.common.constant; package com.uvaluation.common.constant;
/** /**
* 代码生成通用常量 * 代码生成通用常量
* *
* @author ruoyi * @author ruoyi
*/ */
public class GenConstants public class GenConstants
{ {
/** 单表（增删改查） */ /** 单表（增删改查） */
public static final String TPL_CRUD = "crud"; public static final String TPL_CRUD = "crud";
/** 树表（增删改查） */ /** 树表（增删改查） */
public static final String TPL_TREE = "tree"; public static final String TPL_TREE = "tree";
/** 树编码字段 */ /** 树编码字段 */
public static final String TREE_CODE = "treeCode"; public static final String TREE_CODE = "treeCode";
/** 树父编码字段 */ /** 树父编码字段 */
public static final String TREE_PARENT_CODE = "treeParentCode"; public static final String TREE_PARENT_CODE = "treeParentCode";
/** 树名称字段 */ /** 树名称字段 */
public static final String TREE_NAME = "treeName"; public static final String TREE_NAME = "treeName";
/** 数据库字符串类型 */ /** 数据库字符串类型 */
public static final String[] COLUMNTYPE_STR = { "char", "varchar", "narchar", "varchar2", "tinytext", "text", public static final String[] COLUMNTYPE_STR = { "char", "varchar", "narchar", "varchar2", "tinytext", "text",
"mediumtext", "longtext" }; "mediumtext", "longtext" };
/** 数据库时间类型 */ /** 数据库时间类型 */
public static final String[] COLUMNTYPE_TIME = { "datetime", "time", "date", "timestamp" }; public static final String[] COLUMNTYPE_TIME = { "datetime", "time", "date", "timestamp" };
/** 数据库数字类型 */ /** 数据库数字类型 */
public static final String[] COLUMNTYPE_NUMBER = { "tinyint", "smallint", "mediumint", "int", "number", "integer", public static final String[] COLUMNTYPE_NUMBER = { "tinyint", "smallint", "mediumint", "int", "number", "integer",
"bigint", "float", "float", "double", "decimal" }; "bigint", "float", "float", "double", "decimal" };
/** 页面不需要编辑字段 */ /** 页面不需要编辑字段 */
public static final String[] COLUMNNAME_NOT_EDIT = { "id", "create_by", "create_time", "del_flag" }; public static final String[] COLUMNNAME_NOT_EDIT = { "id", "create_by", "create_time", "del_flag" };
/** 页面不需要显示的列表字段 */ /** 页面不需要显示的列表字段 */
public static final String[] COLUMNNAME_NOT_LIST = { "id", "create_by", "create_time", "del_flag", "update_by", public static final String[] COLUMNNAME_NOT_LIST = { "id", "create_by", "create_time", "del_flag", "update_by",
"update_time" }; "update_time" };
/** 页面不需要查询字段 */ /** 页面不需要查询字段 */
public static final String[] COLUMNNAME_NOT_QUERY = { "id", "create_by", "create_time", "del_flag", "update_by", public static final String[] COLUMNNAME_NOT_QUERY = { "id", "create_by", "create_time", "del_flag", "update_by",
"update_time", "remark" }; "update_time", "remark" };
/** Entity基类字段 */ /** Entity基类字段 */
public static final String[] BASE_ENTITY = { "createBy", "createTime", "updateBy", "updateTime", "remark" }; public static final String[] BASE_ENTITY = { "createBy", "createTime", "updateBy", "updateTime", "remark" };
/** Tree基类字段 */ /** Tree基类字段 */
public static final String[] TREE_ENTITY = { "parentName", "parentId", "orderNum", "ancestors", "children" }; public static final String[] TREE_ENTITY = { "parentName", "parentId", "orderNum", "ancestors", "children" };
/** 文本框 */ /** 文本框 */
public static final String HTML_INPUT = "input"; public static final String HTML_INPUT = "input";
/** 文本域 */ /** 文本域 */
public static final String HTML_TEXTAREA = "textarea"; public static final String HTML_TEXTAREA = "textarea";
/** 下拉框 */ /** 下拉框 */
public static final String HTML_SELECT = "select"; public static final String HTML_SELECT = "select";
/** 单选框 */ /** 单选框 */
public static final String HTML_RADIO = "radio"; public static final String HTML_RADIO = "radio";
/** 复选框 */ /** 复选框 */
public static final String HTML_CHECKBOX = "checkbox"; public static final String HTML_CHECKBOX = "checkbox";
/** 日期控件 */ /** 日期控件 */
public static final String HTML_DATETIME = "datetime"; public static final String HTML_DATETIME = "datetime";
/** 字符串类型 */ /** 字符串类型 */
public static final String TYPE_STRING = "String"; public static final String TYPE_STRING = "String";
/** 整型 */ /** 整型 */
public static final String TYPE_INTEGER = "Integer"; public static final String TYPE_INTEGER = "Integer";
/** 长整型 */ /** 长整型 */
public static final String TYPE_LONG = "Long"; public static final String TYPE_LONG = "Long";
/** 浮点型 */ /** 浮点型 */
public static final String TYPE_DOUBLE = "Double"; public static final String TYPE_DOUBLE = "Double";
/** 高精度计算类型 */ /** 高精度计算类型 */
public static final String TYPE_BIGDECIMAL = "BigDecimal"; public static final String TYPE_BIGDECIMAL = "BigDecimal";
/** 时间类型 */ /** 时间类型 */
public static final String TYPE_DATE = "Date"; public static final String TYPE_DATE = "Date";
/** 模糊查询 */ /** 模糊查询 */
public static final String QUERY_LIKE = "LIKE"; public static final String QUERY_LIKE = "LIKE";
/** 需要 */ /** 需要 */
public static final String REQUIRE = "1"; public static final String REQUIRE = "1";
} }

178
ruoyi/src/main/java/com/ruoyi/common/constant/HttpStatus.java → ruoyi/src/main/java/com/uvaluation/common/constant/HttpStatus.java
View File

@ -1,89 +1,89 @@
package com.ruoyi.common.constant; package com.uvaluation.common.constant;
/** /**
* 返回状态码 * 返回状态码
* *
* @author ruoyi * @author ruoyi
*/ */
public interface HttpStatus public interface HttpStatus
{ {
/** /**
* 操作成功 * 操作成功
*/ */
public static final int SUCCESS = 200; public static final int SUCCESS = 200;
/** /**
* 对象创建成功 * 对象创建成功
*/ */
public static final int CREATED = 201; public static final int CREATED = 201;
/** /**
* 请求已经被接受 * 请求已经被接受
*/ */
public static final int ACCEPTED = 202; public static final int ACCEPTED = 202;
/** /**
* 操作已经执行成功，但是没有返回数据 * 操作已经执行成功，但是没有返回数据
*/ */
public static final int NO_CONTENT = 204; public static final int NO_CONTENT = 204;
/** /**
* 资源已被移除 * 资源已被移除
*/ */
public static final int MOVED_PERM = 301; public static final int MOVED_PERM = 301;
/** /**
* 重定向 * 重定向
*/ */
public static final int SEE_OTHER = 303; public static final int SEE_OTHER = 303;
/** /**
* 资源没有被修改 * 资源没有被修改
*/ */
public static final int NOT_MODIFIED = 304; public static final int NOT_MODIFIED = 304;
/** /**
* 参数列表错误（缺少，格式不匹配） * 参数列表错误（缺少，格式不匹配）
*/ */
public static final int BAD_REQUEST = 400; public static final int BAD_REQUEST = 400;
/** /**
* 未授权 * 未授权
*/ */
public static final int UNAUTHORIZED = 401; public static final int UNAUTHORIZED = 401;
/** /**
* 访问受限，授权过期 * 访问受限，授权过期
*/ */
public static final int FORBIDDEN = 403; public static final int FORBIDDEN = 403;
/** /**
* 资源，服务未找到 * 资源，服务未找到
*/ */
public static final int NOT_FOUND = 404; public static final int NOT_FOUND = 404;
/** /**
* 不允许的http方法 * 不允许的http方法
*/ */
public static final int BAD_METHOD = 405; public static final int BAD_METHOD = 405;
/** /**
* 资源冲突，或者资源被锁 * 资源冲突，或者资源被锁
*/ */
public static final int CONFLICT = 409; public static final int CONFLICT = 409;
/** /**
* 不支持的数据，媒体类型 * 不支持的数据，媒体类型
*/ */
public static final int UNSUPPORTED_TYPE = 415; public static final int UNSUPPORTED_TYPE = 415;
/** /**
* 系统内部错误 * 系统内部错误
*/ */
public static final int ERROR = 500; public static final int ERROR = 500;
/** /**
* 接口未实现 * 接口未实现
*/ */
public static final int NOT_IMPLEMENTED = 501; public static final int NOT_IMPLEMENTED = 501;
} }

2
ruoyi/src/main/java/com/ruoyi/common/constant/ScheduleConstants.java → ruoyi/src/main/java/com/uvaluation/common/constant/ScheduleConstants.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.constant; package com.uvaluation.common.constant;
/** /**
* 任务调度通用常量 * 任务调度通用常量

84
ruoyi/src/main/java/com/ruoyi/common/constant/UserConstants.java → ruoyi/src/main/java/com/uvaluation/common/constant/UserConstants.java
View File

@ -1,42 +1,42 @@
package com.ruoyi.common.constant; package com.uvaluation.common.constant;
/** /**
* 用户常量信息 * 用户常量信息
* *
* @author ruoyi * @author ruoyi
*/ */
public class UserConstants public class UserConstants
{ {
/** /**
* 平台内系统用户的唯一标志 * 平台内系统用户的唯一标志
*/ */
public static final String SYS_USER = "SYS_USER"; public static final String SYS_USER = "SYS_USER";
/** 正常状态 */ /** 正常状态 */
public static final String NORMAL = "0"; public static final String NORMAL = "0";
/** 异常状态 */ /** 异常状态 */
public static final String EXCEPTION = "1"; public static final String EXCEPTION = "1";
/** 用户封禁状态 */ /** 用户封禁状态 */
public static final String USER_DISABLE = "1"; public static final String USER_DISABLE = "1";
/** 角色封禁状态 */ /** 角色封禁状态 */
public static final String ROLE_DISABLE = "1"; public static final String ROLE_DISABLE = "1";
/** 部门正常状态 */ /** 部门正常状态 */
public static final String DEPT_NORMAL = "0"; public static final String DEPT_NORMAL = "0";
/** 部门停用状态 */ /** 部门停用状态 */
public static final String DEPT_DISABLE = "1"; public static final String DEPT_DISABLE = "1";
/** 字典正常状态 */ /** 字典正常状态 */
public static final String DICT_NORMAL = "0"; public static final String DICT_NORMAL = "0";
/** 是否为系统默认（是） */ /** 是否为系统默认（是） */
public static final String YES = "Y"; public static final String YES = "Y";
/** 校验返回结果码 */ /** 校验返回结果码 */
public final static String UNIQUE = "0"; public final static String UNIQUE = "0";
public final static String NOT_UNIQUE = "1"; public final static String NOT_UNIQUE = "1";
} }

962
ruoyi/src/main/java/com/ruoyi/common/core/lang/UUID.java → ruoyi/src/main/java/com/uvaluation/common/core/lang/UUID.java
View File

@ -1,481 +1,481 @@
package com.ruoyi.common.core.lang; package com.uvaluation.common.core.lang;
import java.security.MessageDigest; import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException; import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom; import java.security.SecureRandom;
import java.util.Random; import java.util.Random;
import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.ThreadLocalRandom;
import com.ruoyi.common.exception.UtilException; import com.uvaluation.common.exception.UtilException;
/** /**
* 提供通用唯一识别码（universally unique identifier）（UUID）实现 * 提供通用唯一识别码（universally unique identifier）（UUID）实现
* *
* @author ruoyi * @author ruoyi
*/ */
public final class UUID implements java.io.Serializable, Comparable<UUID> public final class UUID implements java.io.Serializable, Comparable<UUID>
{ {
private static final long serialVersionUID = -1185015143654744140L; private static final long serialVersionUID = -1185015143654744140L;
/** /**
* SecureRandom 的单例 * SecureRandom 的单例
* *
*/ */
private static class Holder private static class Holder
{ {
static final SecureRandom numberGenerator = getSecureRandom(); static final SecureRandom numberGenerator = getSecureRandom();
} }
/** 此UUID的最高64有效位 */ /** 此UUID的最高64有效位 */
private final long mostSigBits; private final long mostSigBits;
/** 此UUID的最低64有效位 */ /** 此UUID的最低64有效位 */
private final long leastSigBits; private final long leastSigBits;
/** /**
* 私有构造 * 私有构造
* *
* @param data 数据 * @param data 数据
*/ */
private UUID(byte[] data) private UUID(byte[] data)
{ {
long msb = 0; long msb = 0;
long lsb = 0; long lsb = 0;
assert data.length == 16 : "data must be 16 bytes in length"; assert data.length == 16 : "data must be 16 bytes in length";
for (int i = 0; i < 8; i++) for (int i = 0; i < 8; i++)
{ {
msb = (msb << 8) | (data[i] & 0xff); msb = (msb << 8) | (data[i] & 0xff);
} }
for (int i = 8; i < 16; i++) for (int i = 8; i < 16; i++)
{ {
lsb = (lsb << 8) | (data[i] & 0xff); lsb = (lsb << 8) | (data[i] & 0xff);
} }
this.mostSigBits = msb; this.mostSigBits = msb;
this.leastSigBits = lsb; this.leastSigBits = lsb;
} }
/** /**
* 使用指定的数据构造新的 UUID。 * 使用指定的数据构造新的 UUID。
* *
* @param mostSigBits 用于 {@code UUID} 的最高有效 64 位 * @param mostSigBits 用于 {@code UUID} 的最高有效 64 位
* @param leastSigBits 用于 {@code UUID} 的最低有效 64 位 * @param leastSigBits 用于 {@code UUID} 的最低有效 64 位
*/ */
public UUID(long mostSigBits, long leastSigBits) public UUID(long mostSigBits, long leastSigBits)
{ {
this.mostSigBits = mostSigBits; this.mostSigBits = mostSigBits;
this.leastSigBits = leastSigBits; this.leastSigBits = leastSigBits;
} }
/** /**
* 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的本地线程伪随机数生成器生成该 UUID。 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的本地线程伪随机数生成器生成该 UUID。
* *
* @return 随机生成的 {@code UUID} * @return 随机生成的 {@code UUID}
*/ */
public static UUID fastUUID() public static UUID fastUUID()
{ {
return randomUUID(false); return randomUUID(false);
} }
/** /**
* 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
* *
* @return 随机生成的 {@code UUID} * @return 随机生成的 {@code UUID}
*/ */
public static UUID randomUUID() public static UUID randomUUID()
{ {
return randomUUID(true); return randomUUID(true);
} }
/** /**
* 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。 * 获取类型 4（伪随机生成的）UUID 的静态工厂。 使用加密的强伪随机数生成器生成该 UUID。
* *
* @param isSecure 是否使用{@link SecureRandom}如果是可以获得更安全的随机码，否则可以得到更好的性能 * @param isSecure 是否使用{@link SecureRandom}如果是可以获得更安全的随机码，否则可以得到更好的性能
* @return 随机生成的 {@code UUID} * @return 随机生成的 {@code UUID}
*/ */
public static UUID randomUUID(boolean isSecure) public static UUID randomUUID(boolean isSecure)
{ {
final Random ng = isSecure ? Holder.numberGenerator : getRandom(); final Random ng = isSecure ? Holder.numberGenerator : getRandom();
byte[] randomBytes = new byte[16]; byte[] randomBytes = new byte[16];
ng.nextBytes(randomBytes); ng.nextBytes(randomBytes);
randomBytes[6] &= 0x0f; /* clear version */ randomBytes[6] &= 0x0f; /* clear version */
randomBytes[6] |= 0x40; /* set to version 4 */ randomBytes[6] |= 0x40; /* set to version 4 */
randomBytes[8] &= 0x3f; /* clear variant */ randomBytes[8] &= 0x3f; /* clear variant */
randomBytes[8] |= 0x80; /* set to IETF variant */ randomBytes[8] |= 0x80; /* set to IETF variant */
return new UUID(randomBytes); return new UUID(randomBytes);
} }
/** /**
* 根据指定的字节数组获取类型 3（基于名称的）UUID 的静态工厂。 * 根据指定的字节数组获取类型 3（基于名称的）UUID 的静态工厂。
* *
* @param name 用于构造 UUID 的字节数组。 * @param name 用于构造 UUID 的字节数组。
* *
* @return 根据指定数组生成的 {@code UUID} * @return 根据指定数组生成的 {@code UUID}
*/ */
public static UUID nameUUIDFromBytes(byte[] name) public static UUID nameUUIDFromBytes(byte[] name)
{ {
MessageDigest md; MessageDigest md;
try try
{ {
md = MessageDigest.getInstance("MD5"); md = MessageDigest.getInstance("MD5");
} }
catch (NoSuchAlgorithmException nsae) catch (NoSuchAlgorithmException nsae)
{ {
throw new InternalError("MD5 not supported"); throw new InternalError("MD5 not supported");
} }
byte[] md5Bytes = md.digest(name); byte[] md5Bytes = md.digest(name);
md5Bytes[6] &= 0x0f; /* clear version */ md5Bytes[6] &= 0x0f; /* clear version */
md5Bytes[6] |= 0x30; /* set to version 3 */ md5Bytes[6] |= 0x30; /* set to version 3 */
md5Bytes[8] &= 0x3f; /* clear variant */ md5Bytes[8] &= 0x3f; /* clear variant */
md5Bytes[8] |= 0x80; /* set to IETF variant */ md5Bytes[8] |= 0x80; /* set to IETF variant */
return new UUID(md5Bytes); return new UUID(md5Bytes);
} }
/** /**
* 根据 {@link #toString()} 方法中描述的字符串标准表示形式创建{@code UUID}。 * 根据 {@link #toString()} 方法中描述的字符串标准表示形式创建{@code UUID}。
* *
* @param name 指定 {@code UUID} 字符串 * @param name 指定 {@code UUID} 字符串
* @return 具有指定值的 {@code UUID} * @return 具有指定值的 {@code UUID}
* @throws IllegalArgumentException 如果 name 与 {@link #toString} 中描述的字符串表示形式不符抛出此异常 * @throws IllegalArgumentException 如果 name 与 {@link #toString} 中描述的字符串表示形式不符抛出此异常
* *
*/ */
public static UUID fromString(String name) public static UUID fromString(String name)
{ {
String[] components = name.split("-"); String[] components = name.split("-");
if (components.length != 5) if (components.length != 5)
{ {
throw new IllegalArgumentException("Invalid UUID string: " + name); throw new IllegalArgumentException("Invalid UUID string: " + name);
} }
for (int i = 0; i < 5; i++) for (int i = 0; i < 5; i++)
{ {
components[i] = "0x" + components[i]; components[i] = "0x" + components[i];
} }
long mostSigBits = Long.decode(components[0]).longValue(); long mostSigBits = Long.decode(components[0]).longValue();
mostSigBits <<= 16; mostSigBits <<= 16;
mostSigBits |= Long.decode(components[1]).longValue(); mostSigBits |= Long.decode(components[1]).longValue();
mostSigBits <<= 16; mostSigBits <<= 16;
mostSigBits |= Long.decode(components[2]).longValue(); mostSigBits |= Long.decode(components[2]).longValue();
long leastSigBits = Long.decode(components[3]).longValue(); long leastSigBits = Long.decode(components[3]).longValue();
leastSigBits <<= 48; leastSigBits <<= 48;
leastSigBits |= Long.decode(components[4]).longValue(); leastSigBits |= Long.decode(components[4]).longValue();
return new UUID(mostSigBits, leastSigBits); return new UUID(mostSigBits, leastSigBits);
} }
/** /**
* 返回此 UUID 的 128 位值中的最低有效 64 位。 * 返回此 UUID 的 128 位值中的最低有效 64 位。
* *
* @return 此 UUID 的 128 位值中的最低有效 64 位。 * @return 此 UUID 的 128 位值中的最低有效 64 位。
*/ */
public long getLeastSignificantBits() public long getLeastSignificantBits()
{ {
return leastSigBits; return leastSigBits;
} }
/** /**
* 返回此 UUID 的 128 位值中的最高有效 64 位。 * 返回此 UUID 的 128 位值中的最高有效 64 位。
* *
* @return 此 UUID 的 128 位值中最高有效 64 位。 * @return 此 UUID 的 128 位值中最高有效 64 位。
*/ */
public long getMostSignificantBits() public long getMostSignificantBits()
{ {
return mostSigBits; return mostSigBits;
} }
/** /**
* 与此 {@code UUID} 相关联的版本号. 版本号描述此 {@code UUID} 是如何生成的。 * 与此 {@code UUID} 相关联的版本号. 版本号描述此 {@code UUID} 是如何生成的。
* <p> * <p>
* 版本号具有以下含意: * 版本号具有以下含意:
* <ul> * <ul>
* <li>1 基于时间的 UUID * <li>1 基于时间的 UUID
* <li>2 DCE 安全 UUID * <li>2 DCE 安全 UUID
* <li>3 基于名称的 UUID * <li>3 基于名称的 UUID
* <li>4 随机生成的 UUID * <li>4 随机生成的 UUID
* </ul> * </ul>
* *
* @return 此 {@code UUID} 的版本号 * @return 此 {@code UUID} 的版本号
*/ */
public int version() public int version()
{ {
// Version is bits masked by 0x000000000000F000 in MS long // Version is bits masked by 0x000000000000F000 in MS long
return (int) ((mostSigBits >> 12) & 0x0f); return (int) ((mostSigBits >> 12) & 0x0f);
} }
/** /**
* 与此 {@code UUID} 相关联的变体号。变体号描述 {@code UUID} 的布局。 * 与此 {@code UUID} 相关联的变体号。变体号描述 {@code UUID} 的布局。
* <p> * <p>
* 变体号具有以下含意： * 变体号具有以下含意：
* <ul> * <ul>
* <li>0 为 NCS 向后兼容保留 * <li>0 为 NCS 向后兼容保留
* <li>2 <a href="http://www.ietf.org/rfc/rfc4122.txt">IETF&nbsp;RFC&nbsp;4122</a>(Leach-Salz), 用于此类 * <li>2 <a href="http://www.ietf.org/rfc/rfc4122.txt">IETF&nbsp;RFC&nbsp;4122</a>(Leach-Salz), 用于此类
* <li>6 保留，微软向后兼容 * <li>6 保留，微软向后兼容
* <li>7 保留供以后定义使用 * <li>7 保留供以后定义使用
* </ul> * </ul>
* *
* @return 此 {@code UUID} 相关联的变体号 * @return 此 {@code UUID} 相关联的变体号
*/ */
public int variant() public int variant()
{ {
// This field is composed of a varying number of bits. // This field is composed of a varying number of bits.
// 0 - - Reserved for NCS backward compatibility // 0 - - Reserved for NCS backward compatibility
// 1 0 - The IETF aka Leach-Salz variant (used by this class) // 1 0 - The IETF aka Leach-Salz variant (used by this class)
// 1 1 0 Reserved, Microsoft backward compatibility // 1 1 0 Reserved, Microsoft backward compatibility
// 1 1 1 Reserved for future definition. // 1 1 1 Reserved for future definition.
return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63)); return (int) ((leastSigBits >>> (64 - (leastSigBits >>> 62))) & (leastSigBits >> 63));
} }
/** /**
* 与此 UUID 相关联的时间戳值。 * 与此 UUID 相关联的时间戳值。
* *
* <p> * <p>
* 60 位的时间戳值根据此 {@code UUID} 的 time_low、time_mid 和 time_hi 字段构造。<br> * 60 位的时间戳值根据此 {@code UUID} 的 time_low、time_mid 和 time_hi 字段构造。<br>
* 所得到的时间戳以 100 毫微秒为单位，从 UTC（通用协调时间） 1582 年 10 月 15 日零时开始。 * 所得到的时间戳以 100 毫微秒为单位，从 UTC（通用协调时间） 1582 年 10 月 15 日零时开始。
* *
* <p> * <p>
* 时间戳值仅在在基于时间的 UUID（其 version 类型为 1）中才有意义。<br> * 时间戳值仅在在基于时间的 UUID（其 version 类型为 1）中才有意义。<br>
* 如果此 {@code UUID} 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。 * 如果此 {@code UUID} 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。
* *
* @throws UnsupportedOperationException 如果此 {@code UUID} 不是 version 为 1 的 UUID。 * @throws UnsupportedOperationException 如果此 {@code UUID} 不是 version 为 1 的 UUID。
*/ */
public long timestamp() throws UnsupportedOperationException public long timestamp() throws UnsupportedOperationException
{ {
checkTimeBase(); checkTimeBase();
return (mostSigBits & 0x0FFFL) << 48// return (mostSigBits & 0x0FFFL) << 48//
| ((mostSigBits >> 16) & 0x0FFFFL) << 32// | ((mostSigBits >> 16) & 0x0FFFFL) << 32//
| mostSigBits >>> 32; | mostSigBits >>> 32;
} }
/** /**
* 与此 UUID 相关联的时钟序列值。 * 与此 UUID 相关联的时钟序列值。
* *
* <p> * <p>
* 14 位的时钟序列值根据此 UUID 的 clock_seq 字段构造。clock_seq 字段用于保证在基于时间的 UUID 中的时间唯一性。 * 14 位的时钟序列值根据此 UUID 的 clock_seq 字段构造。clock_seq 字段用于保证在基于时间的 UUID 中的时间唯一性。
* <p> * <p>
* {@code clockSequence} 值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。 如果此 UUID 不是基于时间的 UUID，则此方法抛出 * {@code clockSequence} 值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。 如果此 UUID 不是基于时间的 UUID，则此方法抛出
* UnsupportedOperationException。 * UnsupportedOperationException。
* *
* @return 此 {@code UUID} 的时钟序列 * @return 此 {@code UUID} 的时钟序列
* *
* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1 * @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
*/ */
public int clockSequence() throws UnsupportedOperationException public int clockSequence() throws UnsupportedOperationException
{ {
checkTimeBase(); checkTimeBase();
return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48); return (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
} }
/** /**
* 与此 UUID 相关的节点值。 * 与此 UUID 相关的节点值。
* *
* <p> * <p>
* 48 位的节点值根据此 UUID 的 node 字段构造。此字段旨在用于保存机器的 IEEE 802 地址，该地址用于生成此 UUID 以保证空间唯一性。 * 48 位的节点值根据此 UUID 的 node 字段构造。此字段旨在用于保存机器的 IEEE 802 地址，该地址用于生成此 UUID 以保证空间唯一性。
* <p> * <p>
* 节点值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。<br> * 节点值仅在基于时间的 UUID（其 version 类型为 1）中才有意义。<br>
* 如果此 UUID 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。 * 如果此 UUID 不是基于时间的 UUID，则此方法抛出 UnsupportedOperationException。
* *
* @return 此 {@code UUID} 的节点值 * @return 此 {@code UUID} 的节点值
* *
* @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1 * @throws UnsupportedOperationException 如果此 UUID 的 version 不为 1
*/ */
public long node() throws UnsupportedOperationException public long node() throws UnsupportedOperationException
{ {
checkTimeBase(); checkTimeBase();
return leastSigBits & 0x0000FFFFFFFFFFFFL; return leastSigBits & 0x0000FFFFFFFFFFFFL;
} }
/** /**
* 返回此{@code UUID} 的字符串表现形式。 * 返回此{@code UUID} 的字符串表现形式。
* *
* <p> * <p>
* UUID 的字符串表示形式由此 BNF 描述： * UUID 的字符串表示形式由此 BNF 描述：
* *
* <pre> * <pre>
* {@code * {@code
* UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node> * UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
* time_low = 4*<hexOctet> * time_low = 4*<hexOctet>
* time_mid = 2*<hexOctet> * time_mid = 2*<hexOctet>
* time_high_and_version = 2*<hexOctet> * time_high_and_version = 2*<hexOctet>
* variant_and_sequence = 2*<hexOctet> * variant_and_sequence = 2*<hexOctet>
* node = 6*<hexOctet> * node = 6*<hexOctet>
* hexOctet = <hexDigit><hexDigit> * hexOctet = <hexDigit><hexDigit>
* hexDigit = [0-9a-fA-F] * hexDigit = [0-9a-fA-F]
* } * }
* </pre> * </pre>
* *
* </blockquote> * </blockquote>
* *
* @return 此{@code UUID} 的字符串表现形式 * @return 此{@code UUID} 的字符串表现形式
* @see #toString(boolean) * @see #toString(boolean)
*/ */
@Override @Override
public String toString() public String toString()
{ {
return toString(false); return toString(false);
} }
/** /**
* 返回此{@code UUID} 的字符串表现形式。 * 返回此{@code UUID} 的字符串表现形式。
* *
* <p> * <p>
* UUID 的字符串表示形式由此 BNF 描述： * UUID 的字符串表示形式由此 BNF 描述：
* *
* <pre> * <pre>
* {@code * {@code
* UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node> * UUID = <time_low>-<time_mid>-<time_high_and_version>-<variant_and_sequence>-<node>
* time_low = 4*<hexOctet> * time_low = 4*<hexOctet>
* time_mid = 2*<hexOctet> * time_mid = 2*<hexOctet>
* time_high_and_version = 2*<hexOctet> * time_high_and_version = 2*<hexOctet>
* variant_and_sequence = 2*<hexOctet> * variant_and_sequence = 2*<hexOctet>
* node = 6*<hexOctet> * node = 6*<hexOctet>
* hexOctet = <hexDigit><hexDigit> * hexOctet = <hexDigit><hexDigit>
* hexDigit = [0-9a-fA-F] * hexDigit = [0-9a-fA-F]
* } * }
* </pre> * </pre>
* *
* </blockquote> * </blockquote>
* *
* @param isSimple 是否简单模式，简单模式为不带'-'的UUID字符串 * @param isSimple 是否简单模式，简单模式为不带'-'的UUID字符串
* @return 此{@code UUID} 的字符串表现形式 * @return 此{@code UUID} 的字符串表现形式
*/ */
public String toString(boolean isSimple) public String toString(boolean isSimple)
{ {
final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36); final StringBuilder builder = new StringBuilder(isSimple ? 32 : 36);
// time_low // time_low
builder.append(digits(mostSigBits >> 32, 8)); builder.append(digits(mostSigBits >> 32, 8));
if (false == isSimple) if (false == isSimple)
{ {
builder.append('-'); builder.append('-');
} }
// time_mid // time_mid
builder.append(digits(mostSigBits >> 16, 4)); builder.append(digits(mostSigBits >> 16, 4));
if (false == isSimple) if (false == isSimple)
{ {
builder.append('-'); builder.append('-');
} }
// time_high_and_version // time_high_and_version
builder.append(digits(mostSigBits, 4)); builder.append(digits(mostSigBits, 4));
if (false == isSimple) if (false == isSimple)
{ {
builder.append('-'); builder.append('-');
} }
// variant_and_sequence // variant_and_sequence
builder.append(digits(leastSigBits >> 48, 4)); builder.append(digits(leastSigBits >> 48, 4));
if (false == isSimple) if (false == isSimple)
{ {
builder.append('-'); builder.append('-');
} }
// node // node
builder.append(digits(leastSigBits, 12)); builder.append(digits(leastSigBits, 12));
return builder.toString(); return builder.toString();
} }
/** /**
* 返回此 UUID 的哈希码。 * 返回此 UUID 的哈希码。
* *
* @return UUID 的哈希码值。 * @return UUID 的哈希码值。
*/ */
public int hashCode() public int hashCode()
{ {
long hilo = mostSigBits ^ leastSigBits; long hilo = mostSigBits ^ leastSigBits;
return ((int) (hilo >> 32)) ^ (int) hilo; return ((int) (hilo >> 32)) ^ (int) hilo;
} }
/** /**
* 将此对象与指定对象比较。 * 将此对象与指定对象比较。
* <p> * <p>
* 当且仅当参数不为 {@code null}、而是一个 UUID 对象、具有与此 UUID 相同的 varriant、包含相同的值（每一位均相同）时，结果才为 {@code true}。 * 当且仅当参数不为 {@code null}、而是一个 UUID 对象、具有与此 UUID 相同的 varriant、包含相同的值（每一位均相同）时，结果才为 {@code true}。
* *
* @param obj 要与之比较的对象 * @param obj 要与之比较的对象
* *
* @return 如果对象相同，则返回 {@code true}；否则返回 {@code false} * @return 如果对象相同，则返回 {@code true}；否则返回 {@code false}
*/ */
public boolean equals(Object obj) public boolean equals(Object obj)
{ {
if ((null == obj) || (obj.getClass() != UUID.class)) if ((null == obj) || (obj.getClass() != UUID.class))
{ {
return false; return false;
} }
UUID id = (UUID) obj; UUID id = (UUID) obj;
return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits); return (mostSigBits == id.mostSigBits && leastSigBits == id.leastSigBits);
} }
// Comparison Operations // Comparison Operations
/** /**
* 将此 UUID 与指定的 UUID 比较。 * 将此 UUID 与指定的 UUID 比较。
* *
* <p> * <p>
* 如果两个 UUID 不同，且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段，则第一个 UUID 大于第二个 UUID。 * 如果两个 UUID 不同，且第一个 UUID 的最高有效字段大于第二个 UUID 的对应字段，则第一个 UUID 大于第二个 UUID。
* *
* @param val 与此 UUID 比较的 UUID * @param val 与此 UUID 比较的 UUID
* *
* @return 在此 UUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。 * @return 在此 UUID 小于、等于或大于 val 时，分别返回 -1、0 或 1。
* *
*/ */
public int compareTo(UUID val) public int compareTo(UUID val)
{ {
// The ordering is intentionally set up so that the UUIDs // The ordering is intentionally set up so that the UUIDs
// can simply be numerically compared as two numbers // can simply be numerically compared as two numbers
return (this.mostSigBits < val.mostSigBits ? -1 : // return (this.mostSigBits < val.mostSigBits ? -1 : //
(this.mostSigBits > val.mostSigBits ? 1 : // (this.mostSigBits > val.mostSigBits ? 1 : //
(this.leastSigBits < val.leastSigBits ? -1 : // (this.leastSigBits < val.leastSigBits ? -1 : //
(this.leastSigBits > val.leastSigBits ? 1 : // (this.leastSigBits > val.leastSigBits ? 1 : //
0)))); 0))));
} }
// ------------------------------------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------------------------------------
// Private method start // Private method start
/** /**
* 返回指定数字对应的hex值 * 返回指定数字对应的hex值
* *
* @param val 值 * @param val 值
* @param digits 位 * @param digits 位
* @return 值 * @return 值
*/ */
private static String digits(long val, int digits) private static String digits(long val, int digits)
{ {
long hi = 1L << (digits * 4); long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1); return Long.toHexString(hi | (val & (hi - 1))).substring(1);
} }
/** /**
* 检查是否为time-based版本UUID * 检查是否为time-based版本UUID
*/ */
private void checkTimeBase() private void checkTimeBase()
{ {
if (version() != 1) if (version() != 1)
{ {
throw new UnsupportedOperationException("Not a time-based UUID"); throw new UnsupportedOperationException("Not a time-based UUID");
} }
} }
/** /**
* 获取{@link SecureRandom}，类提供加密的强随机数生成器 (RNG) * 获取{@link SecureRandom}，类提供加密的强随机数生成器 (RNG)
* *
* @return {@link SecureRandom} * @return {@link SecureRandom}
*/ */
public static SecureRandom getSecureRandom() public static SecureRandom getSecureRandom()
{ {
try try
{ {
return SecureRandom.getInstance("SHA1PRNG"); return SecureRandom.getInstance("SHA1PRNG");
} }
catch (NoSuchAlgorithmException e) catch (NoSuchAlgorithmException e)
{ {
throw new UtilException(e); throw new UtilException(e);
} }
} }
/** /**
* 获取随机数生成器对象<br> * 获取随机数生成器对象<br>
* ThreadLocalRandom是JDK 7之后提供并发产生随机数，能够解决多个线程发生的竞争争夺。 * ThreadLocalRandom是JDK 7之后提供并发产生随机数，能够解决多个线程发生的竞争争夺。
* *
* @return {@link ThreadLocalRandom} * @return {@link ThreadLocalRandom}
*/ */
public static ThreadLocalRandom getRandom() public static ThreadLocalRandom getRandom()
{ {
return ThreadLocalRandom.current(); return ThreadLocalRandom.current();
} }
} }

172
ruoyi/src/main/java/com/ruoyi/common/core/text/CharsetKit.java → ruoyi/src/main/java/com/uvaluation/common/core/text/CharsetKit.java
View File

@ -1,86 +1,86 @@
package com.ruoyi.common.core.text; package com.uvaluation.common.core.text;
import java.nio.charset.Charset; import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 字符集工具类 * 字符集工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class CharsetKit public class CharsetKit
{ {
/** ISO-8859-1 */ /** ISO-8859-1 */
public static final String ISO_8859_1 = "ISO-8859-1"; public static final String ISO_8859_1 = "ISO-8859-1";
/** UTF-8 */ /** UTF-8 */
public static final String UTF_8 = "UTF-8"; public static final String UTF_8 = "UTF-8";
/** GBK */ /** GBK */
public static final String GBK = "GBK"; public static final String GBK = "GBK";
/** ISO-8859-1 */ /** ISO-8859-1 */
public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1); public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
/** UTF-8 */ /** UTF-8 */
public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8); public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
/** GBK */ /** GBK */
public static final Charset CHARSET_GBK = Charset.forName(GBK); public static final Charset CHARSET_GBK = Charset.forName(GBK);
/** /**
* 转换为Charset对象 * 转换为Charset对象
* *
* @param charset 字符集，为空则返回默认字符集 * @param charset 字符集，为空则返回默认字符集
* @return Charset * @return Charset
*/ */
public static Charset charset(String charset) public static Charset charset(String charset)
{ {
return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset); return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
} }
/** /**
* 转换字符串的字符集编码 * 转换字符串的字符集编码
* *
* @param source 字符串 * @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1 * @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8 * @param destCharset 目标字符集，默认UTF-8
* @return 转换后的字符集 * @return 转换后的字符集
*/ */
public static String convert(String source, String srcCharset, String destCharset) public static String convert(String source, String srcCharset, String destCharset)
{ {
return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset)); return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
} }
/** /**
* 转换字符串的字符集编码 * 转换字符串的字符集编码
* *
* @param source 字符串 * @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1 * @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8 * @param destCharset 目标字符集，默认UTF-8
* @return 转换后的字符集 * @return 转换后的字符集
*/ */
public static String convert(String source, Charset srcCharset, Charset destCharset) public static String convert(String source, Charset srcCharset, Charset destCharset)
{ {
if (null == srcCharset) if (null == srcCharset)
{ {
srcCharset = StandardCharsets.ISO_8859_1; srcCharset = StandardCharsets.ISO_8859_1;
} }
if (null == destCharset) if (null == destCharset)
{ {
srcCharset = StandardCharsets.UTF_8; srcCharset = StandardCharsets.UTF_8;
} }
if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset))
{ {
return source; return source;
} }
return new String(source.getBytes(srcCharset), destCharset); return new String(source.getBytes(srcCharset), destCharset);
} }
/** /**
* @return 系统字符集编码 * @return 系统字符集编码
*/ */
public static String systemCharset() public static String systemCharset()
{ {
return Charset.defaultCharset().name(); return Charset.defaultCharset().name();
} }
} }

1998
ruoyi/src/main/java/com/ruoyi/common/core/text/Convert.java → ruoyi/src/main/java/com/uvaluation/common/core/text/Convert.java
View File

File diff suppressed because it is too large Load Diff

184
ruoyi/src/main/java/com/ruoyi/common/core/text/StrFormatter.java → ruoyi/src/main/java/com/uvaluation/common/core/text/StrFormatter.java
View File

@ -1,92 +1,92 @@
package com.ruoyi.common.core.text; package com.uvaluation.common.core.text;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 字符串格式化 * 字符串格式化
* *
* @author ruoyi * @author ruoyi
*/ */
public class StrFormatter public class StrFormatter
{ {
public static final String EMPTY_JSON = "{}"; public static final String EMPTY_JSON = "{}";
public static final char C_BACKSLASH = '\\'; public static final char C_BACKSLASH = '\\';
public static final char C_DELIM_START = '{'; public static final char C_DELIM_START = '{';
public static final char C_DELIM_END = '}'; public static final char C_DELIM_END = '}';
/** /**
* 格式化字符串<br> * 格式化字符串<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br> * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br> * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br> * 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br> * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br> * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br> * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
* *
* @param strPattern 字符串模板 * @param strPattern 字符串模板
* @param argArray 参数列表 * @param argArray 参数列表
* @return 结果 * @return 结果
*/ */
public static String format(final String strPattern, final Object... argArray) public static String format(final String strPattern, final Object... argArray)
{ {
if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray)) if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
{ {
return strPattern; return strPattern;
} }
final int strPatternLength = strPattern.length(); final int strPatternLength = strPattern.length();
// 初始化定义好的长度以获得更好的性能 // 初始化定义好的长度以获得更好的性能
StringBuilder sbuf = new StringBuilder(strPatternLength + 50); StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
int handledPosition = 0; int handledPosition = 0;
int delimIndex;// 占位符所在位置 int delimIndex;// 占位符所在位置
for (int argIndex = 0; argIndex < argArray.length; argIndex++) for (int argIndex = 0; argIndex < argArray.length; argIndex++)
{ {
delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition); delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
if (delimIndex == -1) if (delimIndex == -1)
{ {
if (handledPosition == 0) if (handledPosition == 0)
{ {
return strPattern; return strPattern;
} }
else else
{ // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果 { // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
sbuf.append(strPattern, handledPosition, strPatternLength); sbuf.append(strPattern, handledPosition, strPatternLength);
return sbuf.toString(); return sbuf.toString();
} }
} }
else else
{ {
if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH) if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
{ {
if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH) if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
{ {
// 转义符之前还有一个转义符，占位符依旧有效 // 转义符之前还有一个转义符，占位符依旧有效
sbuf.append(strPattern, handledPosition, delimIndex - 1); sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(Convert.utf8Str(argArray[argIndex])); sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2; handledPosition = delimIndex + 2;
} }
else else
{ {
// 占位符被转义 // 占位符被转义
argIndex--; argIndex--;
sbuf.append(strPattern, handledPosition, delimIndex - 1); sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(C_DELIM_START); sbuf.append(C_DELIM_START);
handledPosition = delimIndex + 1; handledPosition = delimIndex + 1;
} }
} }
else else
{ {
// 正常占位符 // 正常占位符
sbuf.append(strPattern, handledPosition, delimIndex); sbuf.append(strPattern, handledPosition, delimIndex);
sbuf.append(Convert.utf8Str(argArray[argIndex])); sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2; handledPosition = delimIndex + 2;
} }
} }
} }
// 加入最后一个占位符后所有的字符 // 加入最后一个占位符后所有的字符
sbuf.append(strPattern, handledPosition, strPattern.length()); sbuf.append(strPattern, handledPosition, strPattern.length());
return sbuf.toString(); return sbuf.toString();
} }
} }

72
ruoyi/src/main/java/com/ruoyi/common/enums/HttpMethod.java → ruoyi/src/main/java/com/uvaluation/common/enums/HttpMethod.java
View File

@ -1,36 +1,36 @@
package com.ruoyi.common.enums; package com.uvaluation.common.enums;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import org.springframework.lang.Nullable; import org.springframework.lang.Nullable;
/** /**
* 请求方式 * 请求方式
* *
* @author ruoyi * @author ruoyi
*/ */
public enum HttpMethod public enum HttpMethod
{ {
GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE; GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE;
private static final Map<String, HttpMethod> mappings = new HashMap<>(16); private static final Map<String, HttpMethod> mappings = new HashMap<>(16);
static static
{ {
for (HttpMethod httpMethod : values()) for (HttpMethod httpMethod : values())
{ {
mappings.put(httpMethod.name(), httpMethod); mappings.put(httpMethod.name(), httpMethod);
} }
} }
@Nullable @Nullable
public static HttpMethod resolve(@Nullable String method) public static HttpMethod resolve(@Nullable String method)
{ {
return (method != null ? mappings.get(method) : null); return (method != null ? mappings.get(method) : null);
} }
public boolean matches(String method) public boolean matches(String method)
{ {
return (this == resolve(method)); return (this == resolve(method));
} }
} }

60
ruoyi/src/main/java/com/ruoyi/common/enums/UserStatus.java → ruoyi/src/main/java/com/uvaluation/common/enums/UserStatus.java
View File

@ -1,30 +1,30 @@
package com.ruoyi.common.enums; package com.uvaluation.common.enums;
/** /**
* 用户状态 * 用户状态
* *
* @author ruoyi * @author ruoyi
*/ */
public enum UserStatus public enum UserStatus
{ {
OK("0", "正常"), DISABLE("1", "停用"), DELETED("2", "删除"); OK("0", "正常"), DISABLE("1", "停用"), DELETED("2", "删除");
private final String code; private final String code;
private final String info; private final String info;
UserStatus(String code, String info) UserStatus(String code, String info)
{ {
this.code = code; this.code = code;
this.info = info; this.info = info;
} }
public String getCode() public String getCode()
{ {
return code; return code;
} }
public String getInfo() public String getInfo()
{ {
return info; return info;
} }
} }

194
ruoyi/src/main/java/com/ruoyi/common/exception/BaseException.java → ruoyi/src/main/java/com/uvaluation/common/exception/BaseException.java
View File

@ -1,97 +1,97 @@
package com.ruoyi.common.exception; package com.uvaluation.common.exception;
import com.ruoyi.common.utils.MessageUtils; import com.uvaluation.common.utils.MessageUtils;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 基础异常 * 基础异常
* *
* @author ruoyi * @author ruoyi
*/ */
public class BaseException extends RuntimeException public class BaseException extends RuntimeException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
/** /**
* 所属模块 * 所属模块
*/ */
private String module; private String module;
/** /**
* 错误码 * 错误码
*/ */
private String code; private String code;
/** /**
* 错误码对应的参数 * 错误码对应的参数
*/ */
private Object[] args; private Object[] args;
/** /**
* 错误消息 * 错误消息
*/ */
private String defaultMessage; private String defaultMessage;
public BaseException(String module, String code, Object[] args, String defaultMessage) public BaseException(String module, String code, Object[] args, String defaultMessage)
{ {
this.module = module; this.module = module;
this.code = code; this.code = code;
this.args = args; this.args = args;
this.defaultMessage = defaultMessage; this.defaultMessage = defaultMessage;
} }
public BaseException(String module, String code, Object[] args) public BaseException(String module, String code, Object[] args)
{ {
this(module, code, args, null); this(module, code, args, null);
} }
public BaseException(String module, String defaultMessage) public BaseException(String module, String defaultMessage)
{ {
this(module, null, null, defaultMessage); this(module, null, null, defaultMessage);
} }
public BaseException(String code, Object[] args) public BaseException(String code, Object[] args)
{ {
this(null, code, args, null); this(null, code, args, null);
} }
public BaseException(String defaultMessage) public BaseException(String defaultMessage)
{ {
this(null, null, null, defaultMessage); this(null, null, null, defaultMessage);
} }
@Override @Override
public String getMessage() public String getMessage()
{ {
String message = null; String message = null;
if (!StringUtils.isEmpty(code)) if (!StringUtils.isEmpty(code))
{ {
message = MessageUtils.message(code, args); message = MessageUtils.message(code, args);
} }
if (message == null) if (message == null)
{ {
message = defaultMessage; message = defaultMessage;
} }
return message; return message;
} }
public String getModule() public String getModule()
{ {
return module; return module;
} }
public String getCode() public String getCode()
{ {
return code; return code;
} }
public Object[] getArgs() public Object[] getArgs()
{ {
return args; return args;
} }
public String getDefaultMessage() public String getDefaultMessage()
{ {
return defaultMessage; return defaultMessage;
} }
} }

86
ruoyi/src/main/java/com/ruoyi/common/exception/CustomException.java → ruoyi/src/main/java/com/uvaluation/common/exception/CustomException.java
View File

@ -1,43 +1,43 @@
package com.ruoyi.common.exception; package com.uvaluation.common.exception;
/** /**
* 自定义异常 * 自定义异常
* *
* @author ruoyi * @author ruoyi
*/ */
public class CustomException extends RuntimeException public class CustomException extends RuntimeException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private Integer code; private Integer code;
private String message; private String message;
public CustomException(String message) public CustomException(String message)
{ {
this.message = message; this.message = message;
} }
public CustomException(String message, Integer code) public CustomException(String message, Integer code)
{ {
this.message = message; this.message = message;
this.code = code; this.code = code;
} }
public CustomException(String message, Throwable e) public CustomException(String message, Throwable e)
{ {
super(message, e); super(message, e);
this.message = message; this.message = message;
} }
@Override @Override
public String getMessage() public String getMessage()
{ {
return message; return message;
} }
public Integer getCode() public Integer getCode()
{ {
return code; return code;
} }
} }

30
ruoyi/src/main/java/com/ruoyi/common/exception/DemoModeException.java → ruoyi/src/main/java/com/uvaluation/common/exception/DemoModeException.java
View File

@ -1,15 +1,15 @@
package com.ruoyi.common.exception; package com.uvaluation.common.exception;
/** /**
* 演示模式异常 * 演示模式异常
* *
* @author ruoyi * @author ruoyi
*/ */
public class DemoModeException extends RuntimeException public class DemoModeException extends RuntimeException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public DemoModeException() public DemoModeException()
{ {
} }
} }

52
ruoyi/src/main/java/com/ruoyi/common/exception/UtilException.java → ruoyi/src/main/java/com/uvaluation/common/exception/UtilException.java
View File

@ -1,26 +1,26 @@
package com.ruoyi.common.exception; package com.uvaluation.common.exception;
/** /**
* 工具类异常 * 工具类异常
* *
* @author ruoyi * @author ruoyi
*/ */
public class UtilException extends RuntimeException public class UtilException extends RuntimeException
{ {
private static final long serialVersionUID = 8247610319171014183L; private static final long serialVersionUID = 8247610319171014183L;
public UtilException(Throwable e) public UtilException(Throwable e)
{ {
super(e.getMessage(), e); super(e.getMessage(), e);
} }
public UtilException(String message) public UtilException(String message)
{ {
super(message); super(message);
} }
public UtilException(String message, Throwable throwable) public UtilException(String message, Throwable throwable)
{ {
super(message, throwable); super(message, throwable);
} }
} }

38
ruoyi/src/main/java/com/ruoyi/common/exception/file/FileException.java → ruoyi/src/main/java/com/uvaluation/common/exception/file/FileException.java
View File

@ -1,19 +1,19 @@
package com.ruoyi.common.exception.file; package com.uvaluation.common.exception.file;
import com.ruoyi.common.exception.BaseException; import com.uvaluation.common.exception.BaseException;
/** /**
* 文件信息异常类 * 文件信息异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class FileException extends BaseException public class FileException extends BaseException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public FileException(String code, Object[] args) public FileException(String code, Object[] args)
{ {
super("file", code, args, null); super("file", code, args, null);
} }
} }

32
ruoyi/src/main/java/com/ruoyi/common/exception/file/FileNameLengthLimitExceededException.java → ruoyi/src/main/java/com/uvaluation/common/exception/file/FileNameLengthLimitExceededException.java
View File

@ -1,16 +1,16 @@
package com.ruoyi.common.exception.file; package com.uvaluation.common.exception.file;
/** /**
* 文件名称超长限制异常类 * 文件名称超长限制异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class FileNameLengthLimitExceededException extends FileException public class FileNameLengthLimitExceededException extends FileException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public FileNameLengthLimitExceededException(int defaultFileNameLength) public FileNameLengthLimitExceededException(int defaultFileNameLength)
{ {
super("upload.filename.exceed.length", new Object[] { defaultFileNameLength }); super("upload.filename.exceed.length", new Object[] { defaultFileNameLength });
} }
} }

32
ruoyi/src/main/java/com/ruoyi/common/exception/file/FileSizeLimitExceededException.java → ruoyi/src/main/java/com/uvaluation/common/exception/file/FileSizeLimitExceededException.java
View File

@ -1,16 +1,16 @@
package com.ruoyi.common.exception.file; package com.uvaluation.common.exception.file;
/** /**
* 文件名大小限制异常类 * 文件名大小限制异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class FileSizeLimitExceededException extends FileException public class FileSizeLimitExceededException extends FileException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public FileSizeLimitExceededException(long defaultMaxSize) public FileSizeLimitExceededException(long defaultMaxSize)
{ {
super("upload.exceed.maxSize", new Object[] { defaultMaxSize }); super("upload.exceed.maxSize", new Object[] { defaultMaxSize });
} }
} }

142
ruoyi/src/main/java/com/ruoyi/common/exception/file/InvalidExtensionException.java → ruoyi/src/main/java/com/uvaluation/common/exception/file/InvalidExtensionException.java
View File

@ -1,71 +1,71 @@
package com.ruoyi.common.exception.file; package com.uvaluation.common.exception.file;
import java.util.Arrays; import java.util.Arrays;
import org.apache.commons.fileupload.FileUploadException; import org.apache.commons.fileupload.FileUploadException;
/** /**
* 文件上传 误异常类 * 文件上传 误异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class InvalidExtensionException extends FileUploadException public class InvalidExtensionException extends FileUploadException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
private String[] allowedExtension; private String[] allowedExtension;
private String extension; private String extension;
private String filename; private String filename;
public InvalidExtensionException(String[] allowedExtension, String extension, String filename) public InvalidExtensionException(String[] allowedExtension, String extension, String filename)
{ {
super("filename : [" + filename + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]"); super("filename : [" + filename + "], extension : [" + extension + "], allowed extension : [" + Arrays.toString(allowedExtension) + "]");
this.allowedExtension = allowedExtension; this.allowedExtension = allowedExtension;
this.extension = extension; this.extension = extension;
this.filename = filename; this.filename = filename;
} }
public String[] getAllowedExtension() public String[] getAllowedExtension()
{ {
return allowedExtension; return allowedExtension;
} }
public String getExtension() public String getExtension()
{ {
return extension; return extension;
} }
public String getFilename() public String getFilename()
{ {
return filename; return filename;
} }
public static class InvalidImageExtensionException extends InvalidExtensionException public static class InvalidImageExtensionException extends InvalidExtensionException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public InvalidImageExtensionException(String[] allowedExtension, String extension, String filename) public InvalidImageExtensionException(String[] allowedExtension, String extension, String filename)
{ {
super(allowedExtension, extension, filename); super(allowedExtension, extension, filename);
} }
} }
public static class InvalidFlashExtensionException extends InvalidExtensionException public static class InvalidFlashExtensionException extends InvalidExtensionException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public InvalidFlashExtensionException(String[] allowedExtension, String extension, String filename) public InvalidFlashExtensionException(String[] allowedExtension, String extension, String filename)
{ {
super(allowedExtension, extension, filename); super(allowedExtension, extension, filename);
} }
} }
public static class InvalidMediaExtensionException extends InvalidExtensionException public static class InvalidMediaExtensionException extends InvalidExtensionException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public InvalidMediaExtensionException(String[] allowedExtension, String extension, String filename) public InvalidMediaExtensionException(String[] allowedExtension, String extension, String filename)
{ {
super(allowedExtension, extension, filename); super(allowedExtension, extension, filename);
} }
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/exception/job/TaskException.java → ruoyi/src/main/java/com/uvaluation/common/exception/job/TaskException.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.exception.job; package com.uvaluation.common.exception.job;
/** /**
* 计划策略异常 * 计划策略异常

32
ruoyi/src/main/java/com/ruoyi/common/exception/user/CaptchaException.java → ruoyi/src/main/java/com/uvaluation/common/exception/user/CaptchaException.java
View File

@ -1,16 +1,16 @@
package com.ruoyi.common.exception.user; package com.uvaluation.common.exception.user;
/** /**
* 验证码错误异常类 * 验证码错误异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class CaptchaException extends UserException public class CaptchaException extends UserException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public CaptchaException() public CaptchaException()
{ {
super("user.jcaptcha.error", null); super("user.jcaptcha.error", null);
} }
} }

32
ruoyi/src/main/java/com/ruoyi/common/exception/user/CaptchaExpireException.java → ruoyi/src/main/java/com/uvaluation/common/exception/user/CaptchaExpireException.java
View File

@ -1,16 +1,16 @@
package com.ruoyi.common.exception.user; package com.uvaluation.common.exception.user;
/** /**
* 验证码失效异常类 * 验证码失效异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class CaptchaExpireException extends UserException public class CaptchaExpireException extends UserException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public CaptchaExpireException() public CaptchaExpireException()
{ {
super("user.jcaptcha.expire", null); super("user.jcaptcha.expire", null);
} }
} }

36
ruoyi/src/main/java/com/ruoyi/common/exception/user/UserException.java → ruoyi/src/main/java/com/uvaluation/common/exception/user/UserException.java
View File

@ -1,18 +1,18 @@
package com.ruoyi.common.exception.user; package com.uvaluation.common.exception.user;
import com.ruoyi.common.exception.BaseException; import com.uvaluation.common.exception.BaseException;
/** /**
* 用户信息异常类 * 用户信息异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class UserException extends BaseException public class UserException extends BaseException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public UserException(String code, Object[] args) public UserException(String code, Object[] args)
{ {
super("user", code, args, null); super("user", code, args, null);
} }
} }

32
ruoyi/src/main/java/com/ruoyi/common/exception/user/UserPasswordNotMatchException.java → ruoyi/src/main/java/com/uvaluation/common/exception/user/UserPasswordNotMatchException.java
View File

@ -1,16 +1,16 @@
package com.ruoyi.common.exception.user; package com.uvaluation.common.exception.user;
/** /**
* 用户密码不正确或不符合规范异常类 * 用户密码不正确或不符合规范异常类
* *
* @author ruoyi * @author ruoyi
*/ */
public class UserPasswordNotMatchException extends UserException public class UserPasswordNotMatchException extends UserException
{ {
private static final long serialVersionUID = 1L; private static final long serialVersionUID = 1L;
public UserPasswordNotMatchException() public UserPasswordNotMatchException()
{ {
super("user.password.not.match", null); super("user.password.not.match", null);
} }
} }

4
ruoyi/src/main/java/com/ruoyi/common/filter/RepeatableFilter.java → ruoyi/src/main/java/com/uvaluation/common/filter/RepeatableFilter.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.filter; package com.uvaluation.common.filter;
import java.io.IOException; import java.io.IOException;
import javax.servlet.Filter; import javax.servlet.Filter;
@ -9,7 +9,7 @@ import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse; import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* Repeatable 过滤器 * Repeatable 过滤器

4
ruoyi/src/main/java/com/ruoyi/common/filter/RepeatedlyRequestWrapper.java → ruoyi/src/main/java/com/uvaluation/common/filter/RepeatedlyRequestWrapper.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.filter; package com.uvaluation.common.filter;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
@ -9,7 +9,7 @@ import javax.servlet.ServletInputStream;
import javax.servlet.ServletResponse; import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper; import javax.servlet.http.HttpServletRequestWrapper;
import com.ruoyi.common.utils.http.HttpHelper; import com.uvaluation.common.utils.http.HttpHelper;
/** /**
* 构建可重复读取inputStream的request * 构建可重复读取inputStream的request

192
ruoyi/src/main/java/com/ruoyi/common/filter/XssFilter.java → ruoyi/src/main/java/com/uvaluation/common/filter/XssFilter.java
View File

@ -1,97 +1,97 @@
package com.ruoyi.common.filter; package com.uvaluation.common.filter;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import java.util.regex.Matcher; import java.util.regex.Matcher;
import java.util.regex.Pattern; import java.util.regex.Pattern;
import javax.servlet.Filter; import javax.servlet.Filter;
import javax.servlet.FilterChain; import javax.servlet.FilterChain;
import javax.servlet.FilterConfig; import javax.servlet.FilterConfig;
import javax.servlet.ServletException; import javax.servlet.ServletException;
import javax.servlet.ServletRequest; import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse; import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 防止XSS攻击的过滤器 * 防止XSS攻击的过滤器
* *
* @author ruoyi * @author ruoyi
*/ */
public class XssFilter implements Filter public class XssFilter implements Filter
{ {
/** /**
* 排除链接 * 排除链接
*/ */
public List<String> excludes = new ArrayList<>(); public List<String> excludes = new ArrayList<>();
/** /**
* xss过滤开关 * xss过滤开关
*/ */
public boolean enabled = false; public boolean enabled = false;
@Override @Override
public void init(FilterConfig filterConfig) throws ServletException public void init(FilterConfig filterConfig) throws ServletException
{ {
String tempExcludes = filterConfig.getInitParameter("excludes"); String tempExcludes = filterConfig.getInitParameter("excludes");
String tempEnabled = filterConfig.getInitParameter("enabled"); String tempEnabled = filterConfig.getInitParameter("enabled");
if (StringUtils.isNotEmpty(tempExcludes)) if (StringUtils.isNotEmpty(tempExcludes))
{ {
String[] url = tempExcludes.split(","); String[] url = tempExcludes.split(",");
for (int i = 0; url != null && i < url.length; i++) for (int i = 0; url != null && i < url.length; i++)
{ {
excludes.add(url[i]); excludes.add(url[i]);
} }
} }
if (StringUtils.isNotEmpty(tempEnabled)) if (StringUtils.isNotEmpty(tempEnabled))
{ {
enabled = Boolean.valueOf(tempEnabled); enabled = Boolean.valueOf(tempEnabled);
} }
} }
@Override @Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException throws IOException, ServletException
{ {
HttpServletRequest req = (HttpServletRequest) request; HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse resp = (HttpServletResponse) response; HttpServletResponse resp = (HttpServletResponse) response;
if (handleExcludeURL(req, resp)) if (handleExcludeURL(req, resp))
{ {
chain.doFilter(request, response); chain.doFilter(request, response);
return; return;
} }
XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request); XssHttpServletRequestWrapper xssRequest = new XssHttpServletRequestWrapper((HttpServletRequest) request);
chain.doFilter(xssRequest, response); chain.doFilter(xssRequest, response);
} }
private boolean handleExcludeURL(HttpServletRequest request, HttpServletResponse response) private boolean handleExcludeURL(HttpServletRequest request, HttpServletResponse response)
{ {
if (!enabled) if (!enabled)
{ {
return true; return true;
} }
if (excludes == null || excludes.isEmpty()) if (excludes == null || excludes.isEmpty())
{ {
return false; return false;
} }
String url = request.getServletPath(); String url = request.getServletPath();
for (String pattern : excludes) for (String pattern : excludes)
{ {
Pattern p = Pattern.compile("^" + pattern); Pattern p = Pattern.compile("^" + pattern);
Matcher m = p.matcher(url); Matcher m = p.matcher(url);
if (m.find()) if (m.find())
{ {
return true; return true;
} }
} }
return false; return false;
} }
@Override @Override
public void destroy() public void destroy()
{ {
} }
} }

208
ruoyi/src/main/java/com/ruoyi/common/filter/XssHttpServletRequestWrapper.java → ruoyi/src/main/java/com/uvaluation/common/filter/XssHttpServletRequestWrapper.java
View File

@ -1,105 +1,105 @@
package com.ruoyi.common.filter; package com.uvaluation.common.filter;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.IOException; import java.io.IOException;
import javax.servlet.ReadListener; import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream; import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper; import javax.servlet.http.HttpServletRequestWrapper;
import org.apache.commons.io.IOUtils; import org.apache.commons.io.IOUtils;
import org.springframework.http.HttpHeaders; import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType; import org.springframework.http.MediaType;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.html.EscapeUtil; import com.uvaluation.common.utils.html.EscapeUtil;
/** /**
* XSS过滤处理 * XSS过滤处理
* *
* @author ruoyi * @author ruoyi
*/ */
public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper public class XssHttpServletRequestWrapper extends HttpServletRequestWrapper
{ {
/** /**
* @param request * @param request
*/ */
public XssHttpServletRequestWrapper(HttpServletRequest request) public XssHttpServletRequestWrapper(HttpServletRequest request)
{ {
super(request); super(request);
} }
@Override @Override
public String[] getParameterValues(String name) public String[] getParameterValues(String name)
{ {
String[] values = super.getParameterValues(name); String[] values = super.getParameterValues(name);
if (values != null) if (values != null)
{ {
int length = values.length; int length = values.length;
String[] escapseValues = new String[length]; String[] escapseValues = new String[length];
for (int i = 0; i < length; i++) for (int i = 0; i < length; i++)
{ {
// 防xss攻击和过滤前后空格 // 防xss攻击和过滤前后空格
escapseValues[i] = EscapeUtil.clean(values[i]).trim(); escapseValues[i] = EscapeUtil.clean(values[i]).trim();
} }
return escapseValues; return escapseValues;
} }
return super.getParameterValues(name); return super.getParameterValues(name);
} }
@Override @Override
public ServletInputStream getInputStream() throws IOException public ServletInputStream getInputStream() throws IOException
{ {
// 非json类型，直接返回 // 非json类型，直接返回
if (!isJsonRequest()) if (!isJsonRequest())
{ {
return super.getInputStream(); return super.getInputStream();
} }
// 为空，直接返回 // 为空，直接返回
String json = IOUtils.toString(super.getInputStream(), "utf-8"); String json = IOUtils.toString(super.getInputStream(), "utf-8");
if (StringUtils.isEmpty(json)) if (StringUtils.isEmpty(json))
{ {
return super.getInputStream(); return super.getInputStream();
} }
// xss过滤 // xss过滤
json = EscapeUtil.clean(json).trim(); json = EscapeUtil.clean(json).trim();
final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes("utf-8")); final ByteArrayInputStream bis = new ByteArrayInputStream(json.getBytes("utf-8"));
return new ServletInputStream() return new ServletInputStream()
{ {
@Override @Override
public boolean isFinished() public boolean isFinished()
{ {
return true; return true;
} }
@Override @Override
public boolean isReady() public boolean isReady()
{ {
return true; return true;
} }
@Override @Override
public void setReadListener(ReadListener readListener) public void setReadListener(ReadListener readListener)
{ {
} }
@Override @Override
public int read() throws IOException public int read() throws IOException
{ {
return bis.read(); return bis.read();
} }
}; };
} }
/** /**
* 是否是Json请求 * 是否是Json请求
* *
* @param request * @param request
*/ */
public boolean isJsonRequest() public boolean isJsonRequest()
{ {
String header = super.getHeader(HttpHeaders.CONTENT_TYPE); String header = super.getHeader(HttpHeaders.CONTENT_TYPE);
return MediaType.APPLICATION_JSON_VALUE.equalsIgnoreCase(header) return MediaType.APPLICATION_JSON_VALUE.equalsIgnoreCase(header)
|| MediaType.APPLICATION_JSON_UTF8_VALUE.equalsIgnoreCase(header); || MediaType.APPLICATION_JSON_UTF8_VALUE.equalsIgnoreCase(header);
} }
} }

228
ruoyi/src/main/java/com/ruoyi/common/utils/Arith.java → ruoyi/src/main/java/com/uvaluation/common/utils/Arith.java
View File

@ -1,114 +1,114 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.math.BigDecimal; import java.math.BigDecimal;
import java.math.RoundingMode; import java.math.RoundingMode;
/** /**
* 精确的浮点数运算 * 精确的浮点数运算
* *
* @author ruoyi * @author ruoyi
*/ */
public class Arith public class Arith
{ {
/** 默认除法运算精度 */ /** 默认除法运算精度 */
private static final int DEF_DIV_SCALE = 10; private static final int DEF_DIV_SCALE = 10;
/** 这个类不能实例化 */ /** 这个类不能实例化 */
private Arith() private Arith()
{ {
} }
/** /**
* 提供精确的加法运算。 * 提供精确的加法运算。
* @param v1 被加数 * @param v1 被加数
* @param v2 加数 * @param v2 加数
* @return 两个参数的和 * @return 两个参数的和
*/ */
public static double add(double v1, double v2) public static double add(double v1, double v2)
{ {
BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2)); BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.add(b2).doubleValue(); return b1.add(b2).doubleValue();
} }
/** /**
* 提供精确的减法运算。 * 提供精确的减法运算。
* @param v1 被减数 * @param v1 被减数
* @param v2 减数 * @param v2 减数
* @return 两个参数的差 * @return 两个参数的差
*/ */
public static double sub(double v1, double v2) public static double sub(double v1, double v2)
{ {
BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2)); BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.subtract(b2).doubleValue(); return b1.subtract(b2).doubleValue();
} }
/** /**
* 提供精确的乘法运算。 * 提供精确的乘法运算。
* @param v1 被乘数 * @param v1 被乘数
* @param v2 乘数 * @param v2 乘数
* @return 两个参数的积 * @return 两个参数的积
*/ */
public static double mul(double v1, double v2) public static double mul(double v1, double v2)
{ {
BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2)); BigDecimal b2 = new BigDecimal(Double.toString(v2));
return b1.multiply(b2).doubleValue(); return b1.multiply(b2).doubleValue();
} }
/** /**
* 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
* 小数点以后10位，以后的数字四舍五入。 * 小数点以后10位，以后的数字四舍五入。
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @return 两个参数的商 * @return 两个参数的商
*/ */
public static double div(double v1, double v2) public static double div(double v1, double v2)
{ {
return div(v1, v2, DEF_DIV_SCALE); return div(v1, v2, DEF_DIV_SCALE);
} }
/** /**
* 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
* 定精度，以后的数字四舍五入。 * 定精度，以后的数字四舍五入。
* @param v1 被除数 * @param v1 被除数
* @param v2 除数 * @param v2 除数
* @param scale 表示表示需要精确到小数点以后几位。 * @param scale 表示表示需要精确到小数点以后几位。
* @return 两个参数的商 * @return 两个参数的商
*/ */
public static double div(double v1, double v2, int scale) public static double div(double v1, double v2, int scale)
{ {
if (scale < 0) if (scale < 0)
{ {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"The scale must be a positive integer or zero"); "The scale must be a positive integer or zero");
} }
BigDecimal b1 = new BigDecimal(Double.toString(v1)); BigDecimal b1 = new BigDecimal(Double.toString(v1));
BigDecimal b2 = new BigDecimal(Double.toString(v2)); BigDecimal b2 = new BigDecimal(Double.toString(v2));
if (b1.compareTo(BigDecimal.ZERO) == 0) if (b1.compareTo(BigDecimal.ZERO) == 0)
{ {
return BigDecimal.ZERO.doubleValue(); return BigDecimal.ZERO.doubleValue();
} }
return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue(); return b1.divide(b2, scale, RoundingMode.HALF_UP).doubleValue();
} }
/** /**
* 提供精确的小数位四舍五入处理。 * 提供精确的小数位四舍五入处理。
* @param v 需要四舍五入的数字 * @param v 需要四舍五入的数字
* @param scale 小数点后保留几位 * @param scale 小数点后保留几位
* @return 四舍五入后的结果 * @return 四舍五入后的结果
*/ */
public static double round(double v, int scale) public static double round(double v, int scale)
{ {
if (scale < 0) if (scale < 0)
{ {
throw new IllegalArgumentException( throw new IllegalArgumentException(
"The scale must be a positive integer or zero"); "The scale must be a positive integer or zero");
} }
BigDecimal b = new BigDecimal(Double.toString(v)); BigDecimal b = new BigDecimal(Double.toString(v));
BigDecimal one = new BigDecimal("1"); BigDecimal one = new BigDecimal("1");
return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue(); return b.divide(one, scale, RoundingMode.HALF_UP).doubleValue();
} }
} }

310
ruoyi/src/main/java/com/ruoyi/common/utils/DateUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/DateUtils.java
View File

@ -1,155 +1,155 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.lang.management.ManagementFactory; import java.lang.management.ManagementFactory;
import java.text.ParseException; import java.text.ParseException;
import java.text.SimpleDateFormat; import java.text.SimpleDateFormat;
import java.util.Date; import java.util.Date;
import org.apache.commons.lang3.time.DateFormatUtils; import org.apache.commons.lang3.time.DateFormatUtils;
/** /**
* 时间工具类 * 时间工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class DateUtils extends org.apache.commons.lang3.time.DateUtils public class DateUtils extends org.apache.commons.lang3.time.DateUtils
{ {
public static String YYYY = "yyyy"; public static String YYYY = "yyyy";
public static String YYYY_MM = "yyyy-MM"; public static String YYYY_MM = "yyyy-MM";
public static String YYYY_MM_DD = "yyyy-MM-dd"; public static String YYYY_MM_DD = "yyyy-MM-dd";
public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss"; public static String YYYYMMDDHHMMSS = "yyyyMMddHHmmss";
public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss"; public static String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";
private static String[] parsePatterns = { private static String[] parsePatterns = {
"yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM", "yyyy-MM-dd", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm", "yyyy-MM",
"yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM", "yyyy/MM/dd", "yyyy/MM/dd HH:mm:ss", "yyyy/MM/dd HH:mm", "yyyy/MM",
"yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"}; "yyyy.MM.dd", "yyyy.MM.dd HH:mm:ss", "yyyy.MM.dd HH:mm", "yyyy.MM"};
/** /**
* 获取当前Date型日期 * 获取当前Date型日期
* *
* @return Date() 当前日期 * @return Date() 当前日期
*/ */
public static Date getNowDate() public static Date getNowDate()
{ {
return new Date(); return new Date();
} }
/** /**
* 获取当前日期, 默认格式为yyyy-MM-dd * 获取当前日期, 默认格式为yyyy-MM-dd
* *
* @return String * @return String
*/ */
public static String getDate() public static String getDate()
{ {
return dateTimeNow(YYYY_MM_DD); return dateTimeNow(YYYY_MM_DD);
} }
public static final String getTime() public static final String getTime()
{ {
return dateTimeNow(YYYY_MM_DD_HH_MM_SS); return dateTimeNow(YYYY_MM_DD_HH_MM_SS);
} }
public static final String dateTimeNow() public static final String dateTimeNow()
{ {
return dateTimeNow(YYYYMMDDHHMMSS); return dateTimeNow(YYYYMMDDHHMMSS);
} }
public static final String dateTimeNow(final String format) public static final String dateTimeNow(final String format)
{ {
return parseDateToStr(format, new Date()); return parseDateToStr(format, new Date());
} }
public static final String dateTime(final Date date) public static final String dateTime(final Date date)
{ {
return parseDateToStr(YYYY_MM_DD, date); return parseDateToStr(YYYY_MM_DD, date);
} }
public static final String parseDateToStr(final String format, final Date date) public static final String parseDateToStr(final String format, final Date date)
{ {
return new SimpleDateFormat(format).format(date); return new SimpleDateFormat(format).format(date);
} }
public static final Date dateTime(final String format, final String ts) public static final Date dateTime(final String format, final String ts)
{ {
try try
{ {
return new SimpleDateFormat(format).parse(ts); return new SimpleDateFormat(format).parse(ts);
} }
catch (ParseException e) catch (ParseException e)
{ {
throw new RuntimeException(e); throw new RuntimeException(e);
} }
} }
/** /**
* 日期路径 即年/月/日 如2018/08/08 * 日期路径 即年/月/日 如2018/08/08
*/ */
public static final String datePath() public static final String datePath()
{ {
Date now = new Date(); Date now = new Date();
return DateFormatUtils.format(now, "yyyy/MM/dd"); return DateFormatUtils.format(now, "yyyy/MM/dd");
} }
/** /**
* 日期路径 即年/月/日 如20180808 * 日期路径 即年/月/日 如20180808
*/ */
public static final String dateTime() public static final String dateTime()
{ {
Date now = new Date(); Date now = new Date();
return DateFormatUtils.format(now, "yyyyMMdd"); return DateFormatUtils.format(now, "yyyyMMdd");
} }
/** /**
* 日期型字符串转化为日期 格式 * 日期型字符串转化为日期 格式
*/ */
public static Date parseDate(Object str) public static Date parseDate(Object str)
{ {
if (str == null) if (str == null)
{ {
return null; return null;
} }
try try
{ {
return parseDate(str.toString(), parsePatterns); return parseDate(str.toString(), parsePatterns);
} }
catch (ParseException e) catch (ParseException e)
{ {
return null; return null;
} }
} }
/** /**
* 获取服务器启动时间 * 获取服务器启动时间
*/ */
public static Date getServerStartDate() public static Date getServerStartDate()
{ {
long time = ManagementFactory.getRuntimeMXBean().getStartTime(); long time = ManagementFactory.getRuntimeMXBean().getStartTime();
return new Date(time); return new Date(time);
} }
/** /**
* 计算两个时间差 * 计算两个时间差
*/ */
public static String getDatePoor(Date endDate, Date nowDate) public static String getDatePoor(Date endDate, Date nowDate)
{ {
long nd = 1000 * 24 * 60 * 60; long nd = 1000 * 24 * 60 * 60;
long nh = 1000 * 60 * 60; long nh = 1000 * 60 * 60;
long nm = 1000 * 60; long nm = 1000 * 60;
// long ns = 1000; // long ns = 1000;
// 获得两个时间的毫秒时间差异 // 获得两个时间的毫秒时间差异
long diff = endDate.getTime() - nowDate.getTime(); long diff = endDate.getTime() - nowDate.getTime();
// 计算差多少天 // 计算差多少天
long day = diff / nd; long day = diff / nd;
// 计算差多少小时 // 计算差多少小时
long hour = diff % nd / nh; long hour = diff % nd / nh;
// 计算差多少分钟 // 计算差多少分钟
long min = diff % nd % nh / nm; long min = diff % nd % nh / nm;
// 计算差多少秒//输出结果 // 计算差多少秒//输出结果
// long sec = diff % nd % nh % nm / ns; // long sec = diff % nd % nh % nm / ns;
return day + "天" + hour + "小时" + min + "分钟"; return day + "天" + hour + "小时" + min + "分钟";
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/utils/ExceptionUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/ExceptionUtil.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.io.PrintWriter; import java.io.PrintWriter;
import java.io.StringWriter; import java.io.StringWriter;

102
ruoyi/src/main/java/com/ruoyi/common/utils/IdUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/IdUtils.java
View File

@ -1,51 +1,51 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import com.ruoyi.common.core.lang.UUID; import com.uvaluation.common.core.lang.UUID;
/** /**
* ID生成器工具类 * ID生成器工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class IdUtils public class IdUtils
{ {
/** /**
* 获取随机UUID * 获取随机UUID
* *
* @return 随机UUID * @return 随机UUID
*/ */
public static String randomUUID() public static String randomUUID()
{ {
return UUID.randomUUID().toString(); return UUID.randomUUID().toString();
} }
/** /**
* 简化的UUID，去掉了横线 * 简化的UUID，去掉了横线
* *
* @return 简化的UUID，去掉了横线 * @return 简化的UUID，去掉了横线
*/ */
public static String simpleUUID() public static String simpleUUID()
{ {
return UUID.randomUUID().toString(true); return UUID.randomUUID().toString(true);
} }
/** /**
* 获取随机UUID，使用性能更好的ThreadLocalRandom生成UUID * 获取随机UUID，使用性能更好的ThreadLocalRandom生成UUID
* *
* @return 随机UUID * @return 随机UUID
*/ */
public static String fastUUID() public static String fastUUID()
{ {
return UUID.fastUUID().toString(); return UUID.fastUUID().toString();
} }
/** /**
* 简化的UUID，去掉了横线，使用性能更好的ThreadLocalRandom生成UUID * 简化的UUID，去掉了横线，使用性能更好的ThreadLocalRandom生成UUID
* *
* @return 简化的UUID，去掉了横线 * @return 简化的UUID，去掉了横线
*/ */
public static String fastSimpleUUID() public static String fastSimpleUUID()
{ {
return UUID.fastUUID().toString(true); return UUID.fastUUID().toString(true);
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/utils/LoadUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/LoadUtil.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;

36
ruoyi/src/main/java/com/ruoyi/common/utils/LogUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/LogUtils.java
View File

@ -1,18 +1,18 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
/** /**
* 处理并记录日志文件 * 处理并记录日志文件
* *
* @author ruoyi * @author ruoyi
*/ */
public class LogUtils public class LogUtils
{ {
public static String getBlock(Object msg) public static String getBlock(Object msg)
{ {
if (msg == null) if (msg == null)
{ {
msg = ""; msg = "";
} }
return "[" + msg.toString() + "]"; return "[" + msg.toString() + "]";
} }
} }

52
ruoyi/src/main/java/com/ruoyi/common/utils/MessageUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/MessageUtils.java
View File

@ -1,26 +1,26 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import org.springframework.context.MessageSource; import org.springframework.context.MessageSource;
import org.springframework.context.i18n.LocaleContextHolder; import org.springframework.context.i18n.LocaleContextHolder;
import com.ruoyi.common.utils.spring.SpringUtils; import com.uvaluation.common.utils.spring.SpringUtils;
/** /**
* 获取i18n资源文件 * 获取i18n资源文件
* *
* @author ruoyi * @author ruoyi
*/ */
public class MessageUtils public class MessageUtils
{ {
/** /**
* 根据消息键和参数 获取消息 委托给spring messageSource * 根据消息键和参数 获取消息 委托给spring messageSource
* *
* @param code 消息键 * @param code 消息键
* @param args 参数 * @param args 参数
* @return 获取国际化翻译值 * @return 获取国际化翻译值
*/ */
public static String message(String code, Object... args) public static String message(String code, Object... args)
{ {
MessageSource messageSource = SpringUtils.getBean(MessageSource.class); MessageSource messageSource = SpringUtils.getBean(MessageSource.class);
return messageSource.getMessage(code, args, LocaleContextHolder.getLocale()); return messageSource.getMessage(code, args, LocaleContextHolder.getLocale());
} }
} }

180
ruoyi/src/main/java/com/ruoyi/common/utils/SecurityUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/SecurityUtils.java
View File

@ -1,90 +1,90 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import org.springframework.security.core.Authentication; import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import com.ruoyi.common.constant.HttpStatus; import com.uvaluation.common.constant.HttpStatus;
import com.ruoyi.common.exception.CustomException; import com.uvaluation.common.exception.CustomException;
import com.ruoyi.framework.security.LoginUser; import com.uvaluation.framework.security.LoginUser;
/** /**
* 安全服务工具类 * 安全服务工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class SecurityUtils public class SecurityUtils
{ {
/** /**
* 获取用户账户 * 获取用户账户
**/ **/
public static String getUsername() public static String getUsername()
{ {
try try
{ {
return getLoginUser().getUsername(); return getLoginUser().getUsername();
} }
catch (Exception e) catch (Exception e)
{ {
throw new CustomException("获取用户账户异常", HttpStatus.UNAUTHORIZED); throw new CustomException("获取用户账户异常", HttpStatus.UNAUTHORIZED);
} }
} }
/** /**
* 获取用户 * 获取用户
**/ **/
public static LoginUser getLoginUser() public static LoginUser getLoginUser()
{ {
try try
{ {
return (LoginUser) getAuthentication().getPrincipal(); return (LoginUser) getAuthentication().getPrincipal();
} }
catch (Exception e) catch (Exception e)
{ {
throw new CustomException("获取用户信息异常", HttpStatus.UNAUTHORIZED); throw new CustomException("获取用户信息异常", HttpStatus.UNAUTHORIZED);
} }
} }
/** /**
* 获取Authentication * 获取Authentication
*/ */
public static Authentication getAuthentication() public static Authentication getAuthentication()
{ {
return SecurityContextHolder.getContext().getAuthentication(); return SecurityContextHolder.getContext().getAuthentication();
} }
/** /**
* 生成BCryptPasswordEncoder密码 * 生成BCryptPasswordEncoder密码
* *
* @param password 密码 * @param password 密码
* @return 加密字符串 * @return 加密字符串
*/ */
public static String encryptPassword(String password) public static String encryptPassword(String password)
{ {
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
return passwordEncoder.encode(password); return passwordEncoder.encode(password);
} }
/** /**
* 判断密码是否相同 * 判断密码是否相同
* *
* @param rawPassword 真实密码 * @param rawPassword 真实密码
* @param encodedPassword 加密后字符 * @param encodedPassword 加密后字符
* @return 结果 * @return 结果
*/ */
public static boolean matchesPassword(String rawPassword, String encodedPassword) public static boolean matchesPassword(String rawPassword, String encodedPassword)
{ {
BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(); BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
return passwordEncoder.matches(rawPassword, encodedPassword); return passwordEncoder.matches(rawPassword, encodedPassword);
} }
/** /**
* 是否为管理员 * 是否为管理员
* *
* @param userId 用户ID * @param userId 用户ID
* @return 结果 * @return 结果
*/ */
public static boolean isAdmin(Long userId) public static boolean isAdmin(Long userId)
{ {
return userId != null && 1L == userId; return userId != null && 1L == userId;
} }
} }

272
ruoyi/src/main/java/com/ruoyi/common/utils/ServletUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/ServletUtils.java
View File

@ -1,136 +1,136 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.io.IOException; import java.io.IOException;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession; import javax.servlet.http.HttpSession;
import org.springframework.web.context.request.RequestAttributes; import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder; import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes; import org.springframework.web.context.request.ServletRequestAttributes;
import com.ruoyi.common.core.text.Convert; import com.uvaluation.common.core.text.Convert;
/** /**
* 客户端工具类 * 客户端工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class ServletUtils public class ServletUtils
{ {
/** /**
* 获取String参数 * 获取String参数
*/ */
public static String getParameter(String name) public static String getParameter(String name)
{ {
return getRequest().getParameter(name); return getRequest().getParameter(name);
} }
/** /**
* 获取String参数 * 获取String参数
*/ */
public static String getParameter(String name, String defaultValue) public static String getParameter(String name, String defaultValue)
{ {
return Convert.toStr(getRequest().getParameter(name), defaultValue); return Convert.toStr(getRequest().getParameter(name), defaultValue);
} }
/** /**
* 获取Integer参数 * 获取Integer参数
*/ */
public static Integer getParameterToInt(String name) public static Integer getParameterToInt(String name)
{ {
return Convert.toInt(getRequest().getParameter(name)); return Convert.toInt(getRequest().getParameter(name));
} }
/** /**
* 获取Integer参数 * 获取Integer参数
*/ */
public static Integer getParameterToInt(String name, Integer defaultValue) public static Integer getParameterToInt(String name, Integer defaultValue)
{ {
return Convert.toInt(getRequest().getParameter(name), defaultValue); return Convert.toInt(getRequest().getParameter(name), defaultValue);
} }
/** /**
* 获取request * 获取request
*/ */
public static HttpServletRequest getRequest() public static HttpServletRequest getRequest()
{ {
return getRequestAttributes().getRequest(); return getRequestAttributes().getRequest();
} }
/** /**
* 获取response * 获取response
*/ */
public static HttpServletResponse getResponse() public static HttpServletResponse getResponse()
{ {
return getRequestAttributes().getResponse(); return getRequestAttributes().getResponse();
} }
/** /**
* 获取session * 获取session
*/ */
public static HttpSession getSession() public static HttpSession getSession()
{ {
return getRequest().getSession(); return getRequest().getSession();
} }
public static ServletRequestAttributes getRequestAttributes() public static ServletRequestAttributes getRequestAttributes()
{ {
RequestAttributes attributes = RequestContextHolder.getRequestAttributes(); RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
return (ServletRequestAttributes) attributes; return (ServletRequestAttributes) attributes;
} }
/** /**
* 将字符串渲染到客户端 * 将字符串渲染到客户端
* *
* @param response 渲染对象 * @param response 渲染对象
* @param string 待渲染的字符串 * @param string 待渲染的字符串
* @return null * @return null
*/ */
public static String renderString(HttpServletResponse response, String string) public static String renderString(HttpServletResponse response, String string)
{ {
try try
{ {
response.setStatus(200); response.setStatus(200);
response.setContentType("application/json"); response.setContentType("application/json");
response.setCharacterEncoding("utf-8"); response.setCharacterEncoding("utf-8");
response.getWriter().print(string); response.getWriter().print(string);
} }
catch (IOException e) catch (IOException e)
{ {
e.printStackTrace(); e.printStackTrace();
} }
return null; return null;
} }
/** /**
* 是否是Ajax异步请求 * 是否是Ajax异步请求
* *
* @param request * @param request
*/ */
public static boolean isAjaxRequest(HttpServletRequest request) public static boolean isAjaxRequest(HttpServletRequest request)
{ {
String accept = request.getHeader("accept"); String accept = request.getHeader("accept");
if (accept != null && accept.indexOf("application/json") != -1) if (accept != null && accept.indexOf("application/json") != -1)
{ {
return true; return true;
} }
String xRequestedWith = request.getHeader("X-Requested-With"); String xRequestedWith = request.getHeader("X-Requested-With");
if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1) if (xRequestedWith != null && xRequestedWith.indexOf("XMLHttpRequest") != -1)
{ {
return true; return true;
} }
String uri = request.getRequestURI(); String uri = request.getRequestURI();
if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml")) if (StringUtils.inStringIgnoreCase(uri, ".json", ".xml"))
{ {
return true; return true;
} }
String ajax = request.getParameter("__ajax"); String ajax = request.getParameter("__ajax");
if (StringUtils.inStringIgnoreCase(ajax, "json", "xml")) if (StringUtils.inStringIgnoreCase(ajax, "json", "xml"))
{ {
return true; return true;
} }
return false; return false;
} }
} }

904
ruoyi/src/main/java/com/ruoyi/common/utils/StringUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/StringUtils.java
View File

@ -1,453 +1,453 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collection; import java.util.Collection;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Set; import java.util.Set;
import com.ruoyi.common.core.text.StrFormatter; import com.uvaluation.common.core.text.StrFormatter;
/** /**
* 字符串工具类 * 字符串工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class StringUtils extends org.apache.commons.lang3.StringUtils public class StringUtils extends org.apache.commons.lang3.StringUtils
{ {
/** 空字符串 */ /** 空字符串 */
private static final String NULLSTR = ""; private static final String NULLSTR = "";
/** 下划线 */ /** 下划线 */
private static final char SEPARATOR = '_'; private static final char SEPARATOR = '_';
/** /**
* 获取参数不为空值 * 获取参数不为空值
* *
* @param value defaultValue 要判断的value * @param value defaultValue 要判断的value
* @return value 返回值 * @return value 返回值
*/ */
public static <T> T nvl(T value, T defaultValue) public static <T> T nvl(T value, T defaultValue)
{ {
return value != null ? value : defaultValue; return value != null ? value : defaultValue;
} }
/** /**
* * 判断一个Collection是否为空， 包含List，Set，Queue * * 判断一个Collection是否为空， 包含List，Set，Queue
* *
* @param coll 要判断的Collection * @param coll 要判断的Collection
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(Collection<?> coll) public static boolean isEmpty(Collection<?> coll)
{ {
return isNull(coll) || coll.isEmpty(); return isNull(coll) || coll.isEmpty();
} }
/** /**
* * 判断一个Collection是否非空，包含List，Set，Queue * * 判断一个Collection是否非空，包含List，Set，Queue
* *
* @param coll 要判断的Collection * @param coll 要判断的Collection
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Collection<?> coll) public static boolean isNotEmpty(Collection<?> coll)
{ {
return !isEmpty(coll); return !isEmpty(coll);
} }
/** /**
* * 判断一个对象数组是否为空 * * 判断一个对象数组是否为空
* *
* @param objects 要判断的对象数组 * @param objects 要判断的对象数组
** @return true：为空 false：非空 ** @return true：为空 false：非空
*/ */
public static boolean isEmpty(Object[] objects) public static boolean isEmpty(Object[] objects)
{ {
return isNull(objects) || (objects.length == 0); return isNull(objects) || (objects.length == 0);
} }
/** /**
* * 判断一个对象数组是否非空 * * 判断一个对象数组是否非空
* *
* @param objects 要判断的对象数组 * @param objects 要判断的对象数组
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Object[] objects) public static boolean isNotEmpty(Object[] objects)
{ {
return !isEmpty(objects); return !isEmpty(objects);
} }
/** /**
* * 判断一个Map是否为空 * * 判断一个Map是否为空
* *
* @param map 要判断的Map * @param map 要判断的Map
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(Map<?, ?> map) public static boolean isEmpty(Map<?, ?> map)
{ {
return isNull(map) || map.isEmpty(); return isNull(map) || map.isEmpty();
} }
/** /**
* * 判断一个Map是否为空 * * 判断一个Map是否为空
* *
* @param map 要判断的Map * @param map 要判断的Map
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotEmpty(Map<?, ?> map) public static boolean isNotEmpty(Map<?, ?> map)
{ {
return !isEmpty(map); return !isEmpty(map);
} }
/** /**
* * 判断一个字符串是否为空串 * * 判断一个字符串是否为空串
* *
* @param str String * @param str String
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isEmpty(String str) public static boolean isEmpty(String str)
{ {
return isNull(str) || NULLSTR.equals(str.trim()); return isNull(str) || NULLSTR.equals(str.trim());
} }
/** /**
* * 判断一个字符串是否为非空串 * * 判断一个字符串是否为非空串
* *
* @param str String * @param str String
* @return true：非空串 false：空串 * @return true：非空串 false：空串
*/ */
public static boolean isNotEmpty(String str) public static boolean isNotEmpty(String str)
{ {
return !isEmpty(str); return !isEmpty(str);
} }
/** /**
* * 判断一个对象是否为空 * * 判断一个对象是否为空
* *
* @param object Object * @param object Object
* @return true：为空 false：非空 * @return true：为空 false：非空
*/ */
public static boolean isNull(Object object) public static boolean isNull(Object object)
{ {
return object == null; return object == null;
} }
/** /**
* * 判断一个对象是否非空 * * 判断一个对象是否非空
* *
* @param object Object * @param object Object
* @return true：非空 false：空 * @return true：非空 false：空
*/ */
public static boolean isNotNull(Object object) public static boolean isNotNull(Object object)
{ {
return !isNull(object); return !isNull(object);
} }
/** /**
* * 判断一个对象是否是数组类型（Java基本型别的数组） * * 判断一个对象是否是数组类型（Java基本型别的数组）
* *
* @param object 对象 * @param object 对象
* @return true：是数组 false：不是数组 * @return true：是数组 false：不是数组
*/ */
public static boolean isArray(Object object) public static boolean isArray(Object object)
{ {
return isNotNull(object) && object.getClass().isArray(); return isNotNull(object) && object.getClass().isArray();
} }
/** /**
* 去空格 * 去空格
*/ */
public static String trim(String str) public static String trim(String str)
{ {
return (str == null ? "" : str.trim()); return (str == null ? "" : str.trim());
} }
/** /**
* 截取字符串 * 截取字符串
* *
* @param str 字符串 * @param str 字符串
* @param start 开始 * @param start 开始
* @return 结果 * @return 结果
*/ */
public static String substring(final String str, int start) public static String substring(final String str, int start)
{ {
if (str == null) if (str == null)
{ {
return NULLSTR; return NULLSTR;
} }
if (start < 0) if (start < 0)
{ {
start = str.length() + start; start = str.length() + start;
} }
if (start < 0) if (start < 0)
{ {
start = 0; start = 0;
} }
if (start > str.length()) if (start > str.length())
{ {
return NULLSTR; return NULLSTR;
} }
return str.substring(start); return str.substring(start);
} }
/** /**
* 截取字符串 * 截取字符串
* *
* @param str 字符串 * @param str 字符串
* @param start 开始 * @param start 开始
* @param end 结束 * @param end 结束
* @return 结果 * @return 结果
*/ */
public static String substring(final String str, int start, int end) public static String substring(final String str, int start, int end)
{ {
if (str == null) if (str == null)
{ {
return NULLSTR; return NULLSTR;
} }
if (end < 0) if (end < 0)
{ {
end = str.length() + end; end = str.length() + end;
} }
if (start < 0) if (start < 0)
{ {
start = str.length() + start; start = str.length() + start;
} }
if (end > str.length()) if (end > str.length())
{ {
end = str.length(); end = str.length();
} }
if (start > end) if (start > end)
{ {
return NULLSTR; return NULLSTR;
} }
if (start < 0) if (start < 0)
{ {
start = 0; start = 0;
} }
if (end < 0) if (end < 0)
{ {
end = 0; end = 0;
} }
return str.substring(start, end); return str.substring(start, end);
} }
/** /**
* 格式化文本, {} 表示占位符<br> * 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br> * 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br> * 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br> * 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br> * 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br> * 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br> * 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
* *
* @param template 文本模板，被替换的部分用 {} 表示 * @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值 * @param params 参数值
* @return 格式化后的文本 * @return 格式化后的文本
*/ */
public static String format(String template, Object... params) public static String format(String template, Object... params)
{ {
if (isEmpty(params) || isEmpty(template)) if (isEmpty(params) || isEmpty(template))
{ {
return template; return template;
} }
return StrFormatter.format(template, params); return StrFormatter.format(template, params);
} }
/** /**
* 字符串转set * 字符串转set
* *
* @param str 字符串 * @param str 字符串
* @param sep 分隔符 * @param sep 分隔符
* @return set集合 * @return set集合
*/ */
public static final Set<String> str2Set(String str, String sep) public static final Set<String> str2Set(String str, String sep)
{ {
return new HashSet<String>(str2List(str, sep, true, false)); return new HashSet<String>(str2List(str, sep, true, false));
} }
/** /**
* 字符串转list * 字符串转list
* *
* @param str 字符串 * @param str 字符串
* @param sep 分隔符 * @param sep 分隔符
* @param filterBlank 过滤纯空白 * @param filterBlank 过滤纯空白
* @param trim 去掉首尾空白 * @param trim 去掉首尾空白
* @return list集合 * @return list集合
*/ */
public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim) public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
{ {
List<String> list = new ArrayList<String>(); List<String> list = new ArrayList<String>();
if (StringUtils.isEmpty(str)) if (StringUtils.isEmpty(str))
{ {
return list; return list;
} }
// 过滤空白字符串 // 过滤空白字符串
if (filterBlank && StringUtils.isBlank(str)) if (filterBlank && StringUtils.isBlank(str))
{ {
return list; return list;
} }
String[] split = str.split(sep); String[] split = str.split(sep);
for (String string : split) for (String string : split)
{ {
if (filterBlank && StringUtils.isBlank(string)) if (filterBlank && StringUtils.isBlank(string))
{ {
continue; continue;
} }
if (trim) if (trim)
{ {
string = string.trim(); string = string.trim();
} }
list.add(string); list.add(string);
} }
return list; return list;
} }
/** /**
* 下划线转驼峰命名 * 下划线转驼峰命名
*/ */
public static String toUnderScoreCase(String str) public static String toUnderScoreCase(String str)
{ {
if (str == null) if (str == null)
{ {
return null; return null;
} }
StringBuilder sb = new StringBuilder(); StringBuilder sb = new StringBuilder();
// 前置字符是否大写 // 前置字符是否大写
boolean preCharIsUpperCase = true; boolean preCharIsUpperCase = true;
// 当前字符是否大写 // 当前字符是否大写
boolean curreCharIsUpperCase = true; boolean curreCharIsUpperCase = true;
// 下一字符是否大写 // 下一字符是否大写
boolean nexteCharIsUpperCase = true; boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++) for (int i = 0; i < str.length(); i++)
{ {
char c = str.charAt(i); char c = str.charAt(i);
if (i > 0) if (i > 0)
{ {
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1)); preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
} }
else else
{ {
preCharIsUpperCase = false; preCharIsUpperCase = false;
} }
curreCharIsUpperCase = Character.isUpperCase(c); curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1)) if (i < (str.length() - 1))
{ {
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1)); nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
} }
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase) if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{ {
sb.append(SEPARATOR); sb.append(SEPARATOR);
} }
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase) else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{ {
sb.append(SEPARATOR); sb.append(SEPARATOR);
} }
sb.append(Character.toLowerCase(c)); sb.append(Character.toLowerCase(c));
} }
return sb.toString(); return sb.toString();
} }
/** /**
* 是否包含字符串 * 是否包含字符串
* *
* @param str 验证字符串 * @param str 验证字符串
* @param strs 字符串组 * @param strs 字符串组
* @return 包含返回true * @return 包含返回true
*/ */
public static boolean inStringIgnoreCase(String str, String... strs) public static boolean inStringIgnoreCase(String str, String... strs)
{ {
if (str != null && strs != null) if (str != null && strs != null)
{ {
for (String s : strs) for (String s : strs)
{ {
if (str.equalsIgnoreCase(trim(s))) if (str.equalsIgnoreCase(trim(s)))
{ {
return true; return true;
} }
} }
} }
return false; return false;
} }
/** /**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld * 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
* *
* @param name 转换前的下划线大写方式命名的字符串 * @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串 * @return 转换后的驼峰式命名的字符串
*/ */
public static String convertToCamelCase(String name) public static String convertToCamelCase(String name)
{ {
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
// 快速检查 // 快速检查
if (name == null || name.isEmpty()) if (name == null || name.isEmpty())
{ {
// 没必要转换 // 没必要转换
return ""; return "";
} }
else if (!name.contains("_")) else if (!name.contains("_"))
{ {
// 不含下划线，仅将首字母大写 // 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1); return name.substring(0, 1).toUpperCase() + name.substring(1);
} }
// 用下划线将原始字符串分割 // 用下划线将原始字符串分割
String[] camels = name.split("_"); String[] camels = name.split("_");
for (String camel : camels) for (String camel : camels)
{ {
// 跳过原始字符串中开头、结尾的下换线或双重下划线 // 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) if (camel.isEmpty())
{ {
continue; continue;
} }
// 首字母大写 // 首字母大写
result.append(camel.substring(0, 1).toUpperCase()); result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase()); result.append(camel.substring(1).toLowerCase());
} }
return result.toString(); return result.toString();
} }
/** /**
* 驼峰式命名法 例如：user_name->userName * 驼峰式命名法 例如：user_name->userName
*/ */
public static String toCamelCase(String s) public static String toCamelCase(String s)
{ {
if (s == null) if (s == null)
{ {
return null; return null;
} }
s = s.toLowerCase(); s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length()); StringBuilder sb = new StringBuilder(s.length());
boolean upperCase = false; boolean upperCase = false;
for (int i = 0; i < s.length(); i++) for (int i = 0; i < s.length(); i++)
{ {
char c = s.charAt(i); char c = s.charAt(i);
if (c == SEPARATOR) if (c == SEPARATOR)
{ {
upperCase = true; upperCase = true;
} }
else if (upperCase) else if (upperCase)
{ {
sb.append(Character.toUpperCase(c)); sb.append(Character.toUpperCase(c));
upperCase = false; upperCase = false;
} }
else else
{ {
sb.append(c); sb.append(c);
} }
} }
return sb.toString(); return sb.toString();
} }
} }

198
ruoyi/src/main/java/com/ruoyi/common/utils/Threads.java → ruoyi/src/main/java/com/uvaluation/common/utils/Threads.java
View File

@ -1,99 +1,99 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.util.concurrent.CancellationException; import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException; import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService; import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future; import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
/** /**
* 线程相关工具类. * 线程相关工具类.
* *
* @author ruoyi * @author ruoyi
*/ */
public class Threads public class Threads
{ {
private static final Logger logger = LoggerFactory.getLogger(Threads.class); private static final Logger logger = LoggerFactory.getLogger(Threads.class);
/** /**
* sleep等待,单位为毫秒 * sleep等待,单位为毫秒
*/ */
public static void sleep(long milliseconds) public static void sleep(long milliseconds)
{ {
try try
{ {
Thread.sleep(milliseconds); Thread.sleep(milliseconds);
} }
catch (InterruptedException e) catch (InterruptedException e)
{ {
return; return;
} }
} }
/** /**
* 停止线程池 * 停止线程池
* 先使用shutdown, 停止接收新任务并尝试完成所有已存在任务. * 先使用shutdown, 停止接收新任务并尝试完成所有已存在任务.
* 如果超时, 则调用shutdownNow, 取消在workQueue中Pending的任务,并中断所有阻塞函数. * 如果超时, 则调用shutdownNow, 取消在workQueue中Pending的任务,并中断所有阻塞函数.
* 如果仍人超時，則強制退出. * 如果仍人超時，則強制退出.
* 另对在shutdown时线程本身被调用中断做了处理. * 另对在shutdown时线程本身被调用中断做了处理.
*/ */
public static void shutdownAndAwaitTermination(ExecutorService pool) public static void shutdownAndAwaitTermination(ExecutorService pool)
{ {
if (pool != null && !pool.isShutdown()) if (pool != null && !pool.isShutdown())
{ {
pool.shutdown(); pool.shutdown();
try try
{ {
if (!pool.awaitTermination(120, TimeUnit.SECONDS)) if (!pool.awaitTermination(120, TimeUnit.SECONDS))
{ {
pool.shutdownNow(); pool.shutdownNow();
if (!pool.awaitTermination(120, TimeUnit.SECONDS)) if (!pool.awaitTermination(120, TimeUnit.SECONDS))
{ {
logger.info("Pool did not terminate"); logger.info("Pool did not terminate");
} }
} }
} }
catch (InterruptedException ie) catch (InterruptedException ie)
{ {
pool.shutdownNow(); pool.shutdownNow();
Thread.currentThread().interrupt(); Thread.currentThread().interrupt();
} }
} }
} }
/** /**
* 打印线程异常信息 * 打印线程异常信息
*/ */
public static void printException(Runnable r, Throwable t) public static void printException(Runnable r, Throwable t)
{ {
if (t == null && r instanceof Future<?>) if (t == null && r instanceof Future<?>)
{ {
try try
{ {
Future<?> future = (Future<?>) r; Future<?> future = (Future<?>) r;
if (future.isDone()) if (future.isDone())
{ {
future.get(); future.get();
} }
} }
catch (CancellationException ce) catch (CancellationException ce)
{ {
t = ce; t = ce;
} }
catch (ExecutionException ee) catch (ExecutionException ee)
{ {
t = ee.getCause(); t = ee.getCause();
} }
catch (InterruptedException ie) catch (InterruptedException ie)
{ {
Thread.currentThread().interrupt(); Thread.currentThread().interrupt();
} }
} }
if (t != null) if (t != null)
{ {
logger.error(t.getMessage(), t); logger.error(t.getMessage(), t);
} }
} }
} }

450
ruoyi/src/main/java/com/ruoyi/common/utils/VerifyCodeUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/VerifyCodeUtils.java
View File

@ -1,226 +1,226 @@
package com.ruoyi.common.utils; package com.uvaluation.common.utils;
import java.awt.Color; import java.awt.Color;
import java.awt.Font; import java.awt.Font;
import java.awt.Graphics; import java.awt.Graphics;
import java.awt.Graphics2D; import java.awt.Graphics2D;
import java.awt.RenderingHints; import java.awt.RenderingHints;
import java.awt.geom.AffineTransform; import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage; import java.awt.image.BufferedImage;
import java.io.IOException; import java.io.IOException;
import java.io.OutputStream; import java.io.OutputStream;
import java.security.SecureRandom; import java.security.SecureRandom;
import java.util.Arrays; import java.util.Arrays;
import java.util.Random; import java.util.Random;
import javax.imageio.ImageIO; import javax.imageio.ImageIO;
/** /**
* 验证码工具类 * 验证码工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class VerifyCodeUtils public class VerifyCodeUtils
{ {
// 使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符 // 使用到Algerian字体，系统里没有的话需要安装字体，字体只显示大写，去掉了1,0,i,o几个容易混淆的字符
public static final String VERIFY_CODES = "123456789ABCDEFGHJKLMNPQRSTUVWXYZ"; public static final String VERIFY_CODES = "123456789ABCDEFGHJKLMNPQRSTUVWXYZ";
private static Random random = new SecureRandom(); private static Random random = new SecureRandom();
/** /**
* 使用系统默认字符源生成验证码 * 使用系统默认字符源生成验证码
* *
* @param verifySize 验证码长度 * @param verifySize 验证码长度
* @return * @return
*/ */
public static String generateVerifyCode(int verifySize) public static String generateVerifyCode(int verifySize)
{ {
return generateVerifyCode(verifySize, VERIFY_CODES); return generateVerifyCode(verifySize, VERIFY_CODES);
} }
/** /**
* 使用指定源生成验证码 * 使用指定源生成验证码
* *
* @param verifySize 验证码长度 * @param verifySize 验证码长度
* @param sources 验证码字符源 * @param sources 验证码字符源
* @return * @return
*/ */
public static String generateVerifyCode(int verifySize, String sources) public static String generateVerifyCode(int verifySize, String sources)
{ {
if (sources == null || sources.length() == 0) if (sources == null || sources.length() == 0)
{ {
sources = VERIFY_CODES; sources = VERIFY_CODES;
} }
int codesLen = sources.length(); int codesLen = sources.length();
Random rand = new Random(System.currentTimeMillis()); Random rand = new Random(System.currentTimeMillis());
StringBuilder verifyCode = new StringBuilder(verifySize); StringBuilder verifyCode = new StringBuilder(verifySize);
for (int i = 0; i < verifySize; i++) for (int i = 0; i < verifySize; i++)
{ {
verifyCode.append(sources.charAt(rand.nextInt(codesLen - 1))); verifyCode.append(sources.charAt(rand.nextInt(codesLen - 1)));
} }
return verifyCode.toString(); return verifyCode.toString();
} }
/** /**
* 输出指定验证码图片流 * 输出指定验证码图片流
* *
* @param w * @param w
* @param h * @param h
* @param os * @param os
* @param code * @param code
* @throws IOException * @throws IOException
*/ */
public static void outputImage(int w, int h, OutputStream os, String code) throws IOException public static void outputImage(int w, int h, OutputStream os, String code) throws IOException
{ {
int verifySize = code.length(); int verifySize = code.length();
BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
Random rand = new Random(); Random rand = new Random();
Graphics2D g2 = image.createGraphics(); Graphics2D g2 = image.createGraphics();
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
Color[] colors = new Color[5]; Color[] colors = new Color[5];
Color[] colorSpaces = new Color[] { Color.WHITE, Color.CYAN, Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA, Color[] colorSpaces = new Color[] { Color.WHITE, Color.CYAN, Color.GRAY, Color.LIGHT_GRAY, Color.MAGENTA,
Color.ORANGE, Color.PINK, Color.YELLOW }; Color.ORANGE, Color.PINK, Color.YELLOW };
float[] fractions = new float[colors.length]; float[] fractions = new float[colors.length];
for (int i = 0; i < colors.length; i++) for (int i = 0; i < colors.length; i++)
{ {
colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)]; colors[i] = colorSpaces[rand.nextInt(colorSpaces.length)];
fractions[i] = rand.nextFloat(); fractions[i] = rand.nextFloat();
} }
Arrays.sort(fractions); Arrays.sort(fractions);
g2.setColor(Color.GRAY);// 设置边框色 g2.setColor(Color.GRAY);// 设置边框色
g2.fillRect(0, 0, w, h); g2.fillRect(0, 0, w, h);
Color c = getRandColor(200, 250); Color c = getRandColor(200, 250);
g2.setColor(c);// 设置背景色 g2.setColor(c);// 设置背景色
g2.fillRect(0, 2, w, h - 4); g2.fillRect(0, 2, w, h - 4);
// 绘制干扰线 // 绘制干扰线
Random random = new Random(); Random random = new Random();
g2.setColor(getRandColor(160, 200));// 设置线条的颜色 g2.setColor(getRandColor(160, 200));// 设置线条的颜色
for (int i = 0; i < 20; i++) for (int i = 0; i < 20; i++)
{ {
int x = random.nextInt(w - 1); int x = random.nextInt(w - 1);
int y = random.nextInt(h - 1); int y = random.nextInt(h - 1);
int xl = random.nextInt(6) + 1; int xl = random.nextInt(6) + 1;
int yl = random.nextInt(12) + 1; int yl = random.nextInt(12) + 1;
g2.drawLine(x, y, x + xl + 40, y + yl + 20); g2.drawLine(x, y, x + xl + 40, y + yl + 20);
} }
// 添加噪点 // 添加噪点
float yawpRate = 0.05f;// 噪声率 float yawpRate = 0.05f;// 噪声率
int area = (int) (yawpRate * w * h); int area = (int) (yawpRate * w * h);
for (int i = 0; i < area; i++) for (int i = 0; i < area; i++)
{ {
int x = random.nextInt(w); int x = random.nextInt(w);
int y = random.nextInt(h); int y = random.nextInt(h);
int rgb = getRandomIntColor(); int rgb = getRandomIntColor();
image.setRGB(x, y, rgb); image.setRGB(x, y, rgb);
} }
shear(g2, w, h, c);// 使图片扭曲 shear(g2, w, h, c);// 使图片扭曲
g2.setColor(getRandColor(100, 160)); g2.setColor(getRandColor(100, 160));
int fontSize = h - 4; int fontSize = h - 4;
Font font = new Font("Algerian", Font.ITALIC, fontSize); Font font = new Font("Algerian", Font.ITALIC, fontSize);
g2.setFont(font); g2.setFont(font);
char[] chars = code.toCharArray(); char[] chars = code.toCharArray();
for (int i = 0; i < verifySize; i++) for (int i = 0; i < verifySize; i++)
{ {
AffineTransform affine = new AffineTransform(); AffineTransform affine = new AffineTransform();
affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1), affine.setToRotation(Math.PI / 4 * rand.nextDouble() * (rand.nextBoolean() ? 1 : -1),
(w / verifySize) * i + fontSize / 2, h / 2); (w / verifySize) * i + fontSize / 2, h / 2);
g2.setTransform(affine); g2.setTransform(affine);
g2.drawChars(chars, i, 1, ((w - 10) / verifySize) * i + 5, h / 2 + fontSize / 2 - 10); g2.drawChars(chars, i, 1, ((w - 10) / verifySize) * i + 5, h / 2 + fontSize / 2 - 10);
} }
g2.dispose(); g2.dispose();
ImageIO.write(image, "jpg", os); ImageIO.write(image, "jpg", os);
} }
private static Color getRandColor(int fc, int bc) private static Color getRandColor(int fc, int bc)
{ {
if (fc > 255) if (fc > 255)
fc = 255; fc = 255;
if (bc > 255) if (bc > 255)
bc = 255; bc = 255;
int r = fc + random.nextInt(bc - fc); int r = fc + random.nextInt(bc - fc);
int g = fc + random.nextInt(bc - fc); int g = fc + random.nextInt(bc - fc);
int b = fc + random.nextInt(bc - fc); int b = fc + random.nextInt(bc - fc);
return new Color(r, g, b); return new Color(r, g, b);
} }
private static int getRandomIntColor() private static int getRandomIntColor()
{ {
int[] rgb = getRandomRgb(); int[] rgb = getRandomRgb();
int color = 0; int color = 0;
for (int c : rgb) for (int c : rgb)
{ {
color = color << 8; color = color << 8;
color = color | c; color = color | c;
} }
return color; return color;
} }
private static int[] getRandomRgb() private static int[] getRandomRgb()
{ {
int[] rgb = new int[3]; int[] rgb = new int[3];
for (int i = 0; i < 3; i++) for (int i = 0; i < 3; i++)
{ {
rgb[i] = random.nextInt(255); rgb[i] = random.nextInt(255);
} }
return rgb; return rgb;
} }
private static void shear(Graphics g, int w1, int h1, Color color) private static void shear(Graphics g, int w1, int h1, Color color)
{ {
shearX(g, w1, h1, color); shearX(g, w1, h1, color);
shearY(g, w1, h1, color); shearY(g, w1, h1, color);
} }
private static void shearX(Graphics g, int w1, int h1, Color color) private static void shearX(Graphics g, int w1, int h1, Color color)
{ {
int period = random.nextInt(2); int period = random.nextInt(2);
boolean borderGap = true; boolean borderGap = true;
int frames = 1; int frames = 1;
int phase = random.nextInt(2); int phase = random.nextInt(2);
for (int i = 0; i < h1; i++) for (int i = 0; i < h1; i++)
{ {
double d = (double) (period >> 1) double d = (double) (period >> 1)
* Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames); * Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);
g.copyArea(0, i, w1, 1, (int) d, 0); g.copyArea(0, i, w1, 1, (int) d, 0);
if (borderGap) if (borderGap)
{ {
g.setColor(color); g.setColor(color);
g.drawLine((int) d, i, 0, i); g.drawLine((int) d, i, 0, i);
g.drawLine((int) d + w1, i, w1, i); g.drawLine((int) d + w1, i, w1, i);
} }
} }
} }
private static void shearY(Graphics g, int w1, int h1, Color color) private static void shearY(Graphics g, int w1, int h1, Color color)
{ {
int period = random.nextInt(40) + 10; // 50; int period = random.nextInt(40) + 10; // 50;
boolean borderGap = true; boolean borderGap = true;
int frames = 20; int frames = 20;
int phase = 7; int phase = 7;
for (int i = 0; i < w1; i++) for (int i = 0; i < w1; i++)
{ {
double d = (double) (period >> 1) double d = (double) (period >> 1)
* Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames); * Math.sin((double) i / (double) period + (6.2831853071795862D * (double) phase) / (double) frames);
g.copyArea(i, 0, 1, h1, 0, (int) d); g.copyArea(i, 0, 1, h1, 0, (int) d);
if (borderGap) if (borderGap)
{ {
g.setColor(color); g.setColor(color);
g.drawLine(i, (int) d, i, 0); g.drawLine(i, (int) d, i, 0);
g.drawLine(i, (int) d + h1, i, h1); g.drawLine(i, (int) d + h1, i, h1);
} }
} }
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/utils/bean/BeanUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/bean/BeanUtils.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.bean; package com.uvaluation.common.utils.bean;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.ArrayList; import java.util.ArrayList;

484
ruoyi/src/main/java/com/ruoyi/common/utils/file/FileUploadUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/file/FileUploadUtils.java
View File

@ -1,243 +1,243 @@
package com.ruoyi.common.utils.file; package com.uvaluation.common.utils.file;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import org.apache.commons.io.FilenameUtils; import org.apache.commons.io.FilenameUtils;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import com.ruoyi.common.constant.Constants; import com.uvaluation.common.constant.Constants;
import com.ruoyi.common.exception.file.FileNameLengthLimitExceededException; import com.uvaluation.common.exception.file.FileNameLengthLimitExceededException;
import com.ruoyi.common.exception.file.FileSizeLimitExceededException; import com.uvaluation.common.exception.file.FileSizeLimitExceededException;
import com.ruoyi.common.exception.file.InvalidExtensionException; import com.uvaluation.common.exception.file.InvalidExtensionException;
import com.ruoyi.common.utils.DateUtils; import com.uvaluation.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.security.Md5Utils; import com.uvaluation.common.utils.security.Md5Utils;
import com.ruoyi.framework.config.RuoYiConfig; import com.uvaluation.framework.config.RuoYiConfig;
/** /**
* 文件上传工具类 * 文件上传工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class FileUploadUtils public class FileUploadUtils
{ {
/** /**
* 默认大小 50M * 默认大小 50M
*/ */
public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024; public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
/** /**
* 默认的文件名最大长度 100 * 默认的文件名最大长度 100
*/ */
public static final int DEFAULT_FILE_NAME_LENGTH = 100; public static final int DEFAULT_FILE_NAME_LENGTH = 100;
/** /**
* 默认上传的地址 * 默认上传的地址
*/ */
private static String defaultBaseDir = RuoYiConfig.getProfile(); private static String defaultBaseDir = RuoYiConfig.getProfile();
private static int counter = 0; private static int counter = 0;
public static void setDefaultBaseDir(String defaultBaseDir) public static void setDefaultBaseDir(String defaultBaseDir)
{ {
FileUploadUtils.defaultBaseDir = defaultBaseDir; FileUploadUtils.defaultBaseDir = defaultBaseDir;
} }
public static String getDefaultBaseDir() public static String getDefaultBaseDir()
{ {
return defaultBaseDir; return defaultBaseDir;
} }
/** /**
* 以默认配置进行文件上传 * 以默认配置进行文件上传
* *
* @param file 上传的文件 * @param file 上传的文件
* @return 文件名称 * @return 文件名称
* @throws Exception * @throws Exception
*/ */
public static final String upload(MultipartFile file) throws IOException public static final String upload(MultipartFile file) throws IOException
{ {
try try
{ {
return upload(getDefaultBaseDir(), file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION); return upload(getDefaultBaseDir(), file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION);
} }
catch (Exception e) catch (Exception e)
{ {
throw new IOException(e.getMessage(), e); throw new IOException(e.getMessage(), e);
} }
} }
/** /**
* 根据文件路径上传 * 根据文件路径上传
* *
* @param baseDir 相对应用的基目录 * @param baseDir 相对应用的基目录
* @param file 上传的文件 * @param file 上传的文件
* @return 文件名称 * @return 文件名称
* @throws IOException * @throws IOException
*/ */
public static final String upload(String baseDir, MultipartFile file) throws IOException public static final String upload(String baseDir, MultipartFile file) throws IOException
{ {
try try
{ {
return upload(baseDir, file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION); return upload(baseDir, file, MimeTypeUtils.DEFAULT_ALLOWED_EXTENSION);
} }
catch (Exception e) catch (Exception e)
{ {
throw new IOException(e.getMessage(), e); throw new IOException(e.getMessage(), e);
} }
} }
/** /**
* 文件上传 * 文件上传
* *
* @param baseDir 相对应用的基目录 * @param baseDir 相对应用的基目录
* @param file 上传的文件 * @param file 上传的文件
* @param extension 上传文件类型 * @param extension 上传文件类型
* @return 返回上传成功的文件名 * @return 返回上传成功的文件名
* @throws FileSizeLimitExceededException 如果超出最大大小 * @throws FileSizeLimitExceededException 如果超出最大大小
* @throws FileNameLengthLimitExceededException 文件名太长 * @throws FileNameLengthLimitExceededException 文件名太长
* @throws IOException 比如读写文件出错时 * @throws IOException 比如读写文件出错时
* @throws InvalidExtensionException 文件校验异常 * @throws InvalidExtensionException 文件校验异常
*/ */
public static final String upload(String baseDir, MultipartFile file, String[] allowedExtension) public static final String upload(String baseDir, MultipartFile file, String[] allowedExtension)
throws FileSizeLimitExceededException, IOException, FileNameLengthLimitExceededException, throws FileSizeLimitExceededException, IOException, FileNameLengthLimitExceededException,
InvalidExtensionException InvalidExtensionException
{ {
int fileNamelength = file.getOriginalFilename().length(); int fileNamelength = file.getOriginalFilename().length();
if (fileNamelength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH) if (fileNamelength > FileUploadUtils.DEFAULT_FILE_NAME_LENGTH)
{ {
throw new FileNameLengthLimitExceededException(FileUploadUtils.DEFAULT_FILE_NAME_LENGTH); throw new FileNameLengthLimitExceededException(FileUploadUtils.DEFAULT_FILE_NAME_LENGTH);
} }
assertAllowed(file, allowedExtension); assertAllowed(file, allowedExtension);
String fileName = extractFilename(file); String fileName = extractFilename(file);
File desc = getAbsoluteFile(baseDir, fileName); File desc = getAbsoluteFile(baseDir, fileName);
file.transferTo(desc); file.transferTo(desc);
String pathFileName = getPathFileName(baseDir, fileName); String pathFileName = getPathFileName(baseDir, fileName);
return pathFileName; return pathFileName;
} }
/** /**
* 编码文件名 * 编码文件名
*/ */
public static final String extractFilename(MultipartFile file) public static final String extractFilename(MultipartFile file)
{ {
String fileName = file.getOriginalFilename(); String fileName = file.getOriginalFilename();
String extension = getExtension(file); String extension = getExtension(file);
fileName = DateUtils.datePath() + "/" + encodingFilename(fileName) + "." + extension; fileName = DateUtils.datePath() + "/" + encodingFilename(fileName) + "." + extension;
return fileName; return fileName;
} }
private static final File getAbsoluteFile(String uploadDir, String fileName) throws IOException private static final File getAbsoluteFile(String uploadDir, String fileName) throws IOException
{ {
File desc = new File(uploadDir + File.separator + fileName); File desc = new File(uploadDir + File.separator + fileName);
if (!desc.getParentFile().exists()) if (!desc.getParentFile().exists())
{ {
desc.getParentFile().mkdirs(); desc.getParentFile().mkdirs();
} }
if (!desc.exists()) if (!desc.exists())
{ {
desc.createNewFile(); desc.createNewFile();
} }
return desc; return desc;
} }
private static final String getPathFileName(String uploadDir, String fileName) throws IOException private static final String getPathFileName(String uploadDir, String fileName) throws IOException
{ {
int dirLastIndex = RuoYiConfig.getProfile().length() + 1; int dirLastIndex = RuoYiConfig.getProfile().length() + 1;
String currentDir = StringUtils.substring(uploadDir, dirLastIndex); String currentDir = StringUtils.substring(uploadDir, dirLastIndex);
String pathFileName = Constants.RESOURCE_PREFIX + "/" + currentDir + "/" + fileName; String pathFileName = Constants.RESOURCE_PREFIX + "/" + currentDir + "/" + fileName;
return pathFileName; return pathFileName;
} }
/** /**
* 编码文件名 * 编码文件名
*/ */
private static final String encodingFilename(String fileName) private static final String encodingFilename(String fileName)
{ {
fileName = fileName.replace("_", " "); fileName = fileName.replace("_", " ");
fileName = Md5Utils.hash(fileName + System.nanoTime() + counter++); fileName = Md5Utils.hash(fileName + System.nanoTime() + counter++);
return fileName; return fileName;
} }
/** /**
* 文件大小校验 * 文件大小校验
* *
* @param file 上传的文件 * @param file 上传的文件
* @return * @return
* @throws FileSizeLimitExceededException 如果超出最大大小 * @throws FileSizeLimitExceededException 如果超出最大大小
* @throws InvalidExtensionException * @throws InvalidExtensionException
*/ */
public static final void assertAllowed(MultipartFile file, String[] allowedExtension) public static final void assertAllowed(MultipartFile file, String[] allowedExtension)
throws FileSizeLimitExceededException, InvalidExtensionException throws FileSizeLimitExceededException, InvalidExtensionException
{ {
long size = file.getSize(); long size = file.getSize();
if (DEFAULT_MAX_SIZE != -1 && size > DEFAULT_MAX_SIZE) if (DEFAULT_MAX_SIZE != -1 && size > DEFAULT_MAX_SIZE)
{ {
throw new FileSizeLimitExceededException(DEFAULT_MAX_SIZE / 1024 / 1024); throw new FileSizeLimitExceededException(DEFAULT_MAX_SIZE / 1024 / 1024);
} }
String fileName = file.getOriginalFilename(); String fileName = file.getOriginalFilename();
String extension = getExtension(file); String extension = getExtension(file);
if (allowedExtension != null && !isAllowedExtension(extension, allowedExtension)) if (allowedExtension != null && !isAllowedExtension(extension, allowedExtension))
{ {
if (allowedExtension == MimeTypeUtils.IMAGE_EXTENSION) if (allowedExtension == MimeTypeUtils.IMAGE_EXTENSION)
{ {
throw new InvalidExtensionException.InvalidImageExtensionException(allowedExtension, extension, throw new InvalidExtensionException.InvalidImageExtensionException(allowedExtension, extension,
fileName); fileName);
} }
else if (allowedExtension == MimeTypeUtils.FLASH_EXTENSION) else if (allowedExtension == MimeTypeUtils.FLASH_EXTENSION)
{ {
throw new InvalidExtensionException.InvalidFlashExtensionException(allowedExtension, extension, throw new InvalidExtensionException.InvalidFlashExtensionException(allowedExtension, extension,
fileName); fileName);
} }
else if (allowedExtension == MimeTypeUtils.MEDIA_EXTENSION) else if (allowedExtension == MimeTypeUtils.MEDIA_EXTENSION)
{ {
throw new InvalidExtensionException.InvalidMediaExtensionException(allowedExtension, extension, throw new InvalidExtensionException.InvalidMediaExtensionException(allowedExtension, extension,
fileName); fileName);
} }
else else
{ {
throw new InvalidExtensionException(allowedExtension, extension, fileName); throw new InvalidExtensionException(allowedExtension, extension, fileName);
} }
} }
} }
/** /**
* 判断MIME类型是否是允许的MIME类型 * 判断MIME类型是否是允许的MIME类型
* *
* @param extension * @param extension
* @param allowedExtension * @param allowedExtension
* @return * @return
*/ */
public static final boolean isAllowedExtension(String extension, String[] allowedExtension) public static final boolean isAllowedExtension(String extension, String[] allowedExtension)
{ {
for (String str : allowedExtension) for (String str : allowedExtension)
{ {
if (str.equalsIgnoreCase(extension)) if (str.equalsIgnoreCase(extension))
{ {
return true; return true;
} }
} }
return false; return false;
} }
/** /**
* 获取文件名的后缀 * 获取文件名的后缀
* *
* @param file 表单文件 * @param file 表单文件
* @return 后缀名 * @return 后缀名
*/ */
public static final String getExtension(MultipartFile file) public static final String getExtension(MultipartFile file)
{ {
String extension = FilenameUtils.getExtension(file.getOriginalFilename()); String extension = FilenameUtils.getExtension(file.getOriginalFilename());
if (StringUtils.isEmpty(extension)) if (StringUtils.isEmpty(extension))
{ {
extension = MimeTypeUtils.getExtension(file.getContentType()); extension = MimeTypeUtils.getExtension(file.getContentType());
} }
return extension; return extension;
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/utils/file/FileUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/file/FileUtils.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.file; package com.uvaluation.common.utils.file;
import java.io.*; import java.io.*;
import java.net.URLEncoder; import java.net.URLEncoder;

110
ruoyi/src/main/java/com/ruoyi/common/utils/file/MimeTypeUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/file/MimeTypeUtils.java
View File

@ -1,55 +1,55 @@
package com.ruoyi.common.utils.file; package com.uvaluation.common.utils.file;
/** /**
* 媒体类型工具类 * 媒体类型工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class MimeTypeUtils public class MimeTypeUtils
{ {
public static final String IMAGE_PNG = "image/png"; public static final String IMAGE_PNG = "image/png";
public static final String IMAGE_JPG = "image/jpg"; public static final String IMAGE_JPG = "image/jpg";
public static final String IMAGE_JPEG = "image/jpeg"; public static final String IMAGE_JPEG = "image/jpeg";
public static final String IMAGE_BMP = "image/bmp"; public static final String IMAGE_BMP = "image/bmp";
public static final String IMAGE_GIF = "image/gif"; public static final String IMAGE_GIF = "image/gif";
public static final String[] IMAGE_EXTENSION = { "bmp", "gif", "jpg", "jpeg", "png" }; public static final String[] IMAGE_EXTENSION = { "bmp", "gif", "jpg", "jpeg", "png" };
public static final String[] FLASH_EXTENSION = { "swf", "flv" }; public static final String[] FLASH_EXTENSION = { "swf", "flv" };
public static final String[] MEDIA_EXTENSION = { "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg", public static final String[] MEDIA_EXTENSION = { "swf", "flv", "mp3", "wav", "wma", "wmv", "mid", "avi", "mpg",
"asf", "rm", "rmvb" }; "asf", "rm", "rmvb" };
public static final String[] DEFAULT_ALLOWED_EXTENSION = { public static final String[] DEFAULT_ALLOWED_EXTENSION = {
// 图片 // 图片
"bmp", "gif", "jpg", "jpeg", "png", "bmp", "gif", "jpg", "jpeg", "png",
// word excel powerpoint // word excel powerpoint
"doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "html", "htm", "txt",
// 压缩文件 // 压缩文件
"rar", "zip", "gz", "bz2", "rar", "zip", "gz", "bz2",
// pdf // pdf
"pdf" }; "pdf" };
public static String getExtension(String prefix) public static String getExtension(String prefix)
{ {
switch (prefix) switch (prefix)
{ {
case IMAGE_PNG: case IMAGE_PNG:
return "png"; return "png";
case IMAGE_JPG: case IMAGE_JPG:
return "jpg"; return "jpg";
case IMAGE_JPEG: case IMAGE_JPEG:
return "jpeg"; return "jpeg";
case IMAGE_BMP: case IMAGE_BMP:
return "bmp"; return "bmp";
case IMAGE_GIF: case IMAGE_GIF:
return "gif"; return "gif";
default: default:
return ""; return "";
} }
} }
} }

304
ruoyi/src/main/java/com/ruoyi/common/utils/html/EscapeUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/html/EscapeUtil.java
View File

@ -1,152 +1,152 @@
package com.ruoyi.common.utils.html; package com.uvaluation.common.utils.html;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 转义和反转义工具类 * 转义和反转义工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class EscapeUtil public class EscapeUtil
{ {
public static final String RE_HTML_MARK = "(<[^<]*?>)|(<[\\s]*?/[^<]*?>)|(<[^<]*?/[\\s]*?>)"; public static final String RE_HTML_MARK = "(<[^<]*?>)|(<[\\s]*?/[^<]*?>)|(<[^<]*?/[\\s]*?>)";
private static final char[][] TEXT = new char[64][]; private static final char[][] TEXT = new char[64][];
static static
{ {
for (int i = 0; i < 64; i++) for (int i = 0; i < 64; i++)
{ {
TEXT[i] = new char[] { (char) i }; TEXT[i] = new char[] { (char) i };
} }
// special HTML characters // special HTML characters
TEXT['\''] = "&#039;".toCharArray(); // 单引号 TEXT['\''] = "&#039;".toCharArray(); // 单引号
TEXT['"'] = "&#34;".toCharArray(); // 单引号 TEXT['"'] = "&#34;".toCharArray(); // 单引号
TEXT['&'] = "&#38;".toCharArray(); // &符 TEXT['&'] = "&#38;".toCharArray(); // &符
TEXT['<'] = "&#60;".toCharArray(); // 小于号 TEXT['<'] = "&#60;".toCharArray(); // 小于号
TEXT['>'] = "&#62;".toCharArray(); // 大于号 TEXT['>'] = "&#62;".toCharArray(); // 大于号
} }
/** /**
* 转义文本中的HTML字符为安全的字符 * 转义文本中的HTML字符为安全的字符
* *
* @param text 被转义的文本 * @param text 被转义的文本
* @return 转义后的文本 * @return 转义后的文本
*/ */
public static String escape(String text) public static String escape(String text)
{ {
return encode(text); return encode(text);
} }
/** /**
* 还原被转义的HTML特殊字符 * 还原被转义的HTML特殊字符
* *
* @param content 包含转义符的HTML内容 * @param content 包含转义符的HTML内容
* @return 转换后的字符串 * @return 转换后的字符串
*/ */
public static String unescape(String content) public static String unescape(String content)
{ {
return decode(content); return decode(content);
} }
/** /**
* 清除所有HTML标签，但是不删除标签内的内容 * 清除所有HTML标签，但是不删除标签内的内容
* *
* @param content 文本 * @param content 文本
* @return 清除标签后的文本 * @return 清除标签后的文本
*/ */
public static String clean(String content) public static String clean(String content)
{ {
return new HTMLFilter().filter(content); return new HTMLFilter().filter(content);
} }
/** /**
* Escape编码 * Escape编码
* *
* @param text 被编码的文本 * @param text 被编码的文本
* @return 编码后的字符 * @return 编码后的字符
*/ */
private static String encode(String text) private static String encode(String text)
{ {
int len; int len;
if ((text == null) || ((len = text.length()) == 0)) if ((text == null) || ((len = text.length()) == 0))
{ {
return StringUtils.EMPTY; return StringUtils.EMPTY;
} }
StringBuilder buffer = new StringBuilder(len + (len >> 2)); StringBuilder buffer = new StringBuilder(len + (len >> 2));
char c; char c;
for (int i = 0; i < len; i++) for (int i = 0; i < len; i++)
{ {
c = text.charAt(i); c = text.charAt(i);
if (c < 64) if (c < 64)
{ {
buffer.append(TEXT[c]); buffer.append(TEXT[c]);
} }
else else
{ {
buffer.append(c); buffer.append(c);
} }
} }
return buffer.toString(); return buffer.toString();
} }
/** /**
* Escape解码 * Escape解码
* *
* @param content 被转义的内容 * @param content 被转义的内容
* @return 解码后的字符串 * @return 解码后的字符串
*/ */
public static String decode(String content) public static String decode(String content)
{ {
if (StringUtils.isEmpty(content)) if (StringUtils.isEmpty(content))
{ {
return content; return content;
} }
StringBuilder tmp = new StringBuilder(content.length()); StringBuilder tmp = new StringBuilder(content.length());
int lastPos = 0, pos = 0; int lastPos = 0, pos = 0;
char ch; char ch;
while (lastPos < content.length()) while (lastPos < content.length())
{ {
pos = content.indexOf("%", lastPos); pos = content.indexOf("%", lastPos);
if (pos == lastPos) if (pos == lastPos)
{ {
if (content.charAt(pos + 1) == 'u') if (content.charAt(pos + 1) == 'u')
{ {
ch = (char) Integer.parseInt(content.substring(pos + 2, pos + 6), 16); ch = (char) Integer.parseInt(content.substring(pos + 2, pos + 6), 16);
tmp.append(ch); tmp.append(ch);
lastPos = pos + 6; lastPos = pos + 6;
} }
else else
{ {
ch = (char) Integer.parseInt(content.substring(pos + 1, pos + 3), 16); ch = (char) Integer.parseInt(content.substring(pos + 1, pos + 3), 16);
tmp.append(ch); tmp.append(ch);
lastPos = pos + 3; lastPos = pos + 3;
} }
} }
else else
{ {
if (pos == -1) if (pos == -1)
{ {
tmp.append(content.substring(lastPos)); tmp.append(content.substring(lastPos));
lastPos = content.length(); lastPos = content.length();
} }
else else
{ {
tmp.append(content.substring(lastPos, pos)); tmp.append(content.substring(lastPos, pos));
lastPos = pos; lastPos = pos;
} }
} }
} }
return tmp.toString(); return tmp.toString();
} }
public static void main(String[] args) public static void main(String[] args)
{ {
String html = "alert('11111');"; String html = "alert('11111');";
System.out.println(EscapeUtil.clean(html)); System.out.println(EscapeUtil.clean(html));
System.out.println(EscapeUtil.escape(html)); System.out.println(EscapeUtil.escape(html));
System.out.println(EscapeUtil.unescape(html)); System.out.println(EscapeUtil.unescape(html));
} }
} }

2
ruoyi/src/main/java/com/ruoyi/common/utils/html/HTMLFilter.java → ruoyi/src/main/java/com/uvaluation/common/utils/html/HTMLFilter.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.html; package com.uvaluation.common.utils.html;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Collections; import java.util.Collections;

2
ruoyi/src/main/java/com/ruoyi/common/utils/http/HttpHelper.java → ruoyi/src/main/java/com/uvaluation/common/utils/http/HttpHelper.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.http; package com.uvaluation.common.utils.http;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;

522
ruoyi/src/main/java/com/ruoyi/common/utils/http/HttpUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/http/HttpUtils.java
View File

@ -1,262 +1,262 @@
package com.ruoyi.common.utils.http; package com.uvaluation.common.utils.http;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
import java.io.InputStreamReader; import java.io.InputStreamReader;
import java.io.PrintWriter; import java.io.PrintWriter;
import java.net.ConnectException; import java.net.ConnectException;
import java.net.SocketTimeoutException; import java.net.SocketTimeoutException;
import java.net.URL; import java.net.URL;
import java.net.URLConnection; import java.net.URLConnection;
import java.security.cert.X509Certificate; import java.security.cert.X509Certificate;
import javax.net.ssl.HostnameVerifier; import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext; import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession; import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager; import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager; import javax.net.ssl.X509TrustManager;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.ruoyi.common.constant.Constants; import com.uvaluation.common.constant.Constants;
/** /**
* 通用http发送方法 * 通用http发送方法
* *
* @author ruoyi * @author ruoyi
*/ */
public class HttpUtils public class HttpUtils
{ {
private static final Logger log = LoggerFactory.getLogger(HttpUtils.class); private static final Logger log = LoggerFactory.getLogger(HttpUtils.class);
/** /**
* 向指定 URL 发送GET方法的请求 * 向指定 URL 发送GET方法的请求
* *
* @param url 发送请求的 URL * @param url 发送请求的 URL
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。 * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
* @return 所代表远程资源的响应结果 * @return 所代表远程资源的响应结果
*/ */
public static String sendGet(String url, String param) public static String sendGet(String url, String param)
{ {
return sendGet(url, param, Constants.UTF8); return sendGet(url, param, Constants.UTF8);
} }
/** /**
* 向指定 URL 发送GET方法的请求 * 向指定 URL 发送GET方法的请求
* *
* @param url 发送请求的 URL * @param url 发送请求的 URL
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。 * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
* @param contentType 编码类型 * @param contentType 编码类型
* @return 所代表远程资源的响应结果 * @return 所代表远程资源的响应结果
*/ */
public static String sendGet(String url, String param, String contentType) public static String sendGet(String url, String param, String contentType)
{ {
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
BufferedReader in = null; BufferedReader in = null;
try try
{ {
String urlNameString = url + "?" + param; String urlNameString = url + "?" + param;
log.info("sendGet - {}", urlNameString); log.info("sendGet - {}", urlNameString);
URL realUrl = new URL(urlNameString); URL realUrl = new URL(urlNameString);
URLConnection connection = realUrl.openConnection(); URLConnection connection = realUrl.openConnection();
connection.setRequestProperty("accept", "*/*"); connection.setRequestProperty("accept", "*/*");
connection.setRequestProperty("connection", "Keep-Alive"); connection.setRequestProperty("connection", "Keep-Alive");
connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)"); connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
connection.connect(); connection.connect();
in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType)); in = new BufferedReader(new InputStreamReader(connection.getInputStream(), contentType));
String line; String line;
while ((line = in.readLine()) != null) while ((line = in.readLine()) != null)
{ {
result.append(line); result.append(line);
} }
log.info("recv - {}", result); log.info("recv - {}", result);
} }
catch (ConnectException e) catch (ConnectException e)
{ {
log.error("调用HttpUtils.sendGet ConnectException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendGet ConnectException, url=" + url + ",param=" + param, e);
} }
catch (SocketTimeoutException e) catch (SocketTimeoutException e)
{ {
log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendGet SocketTimeoutException, url=" + url + ",param=" + param, e);
} }
catch (IOException e) catch (IOException e)
{ {
log.error("调用HttpUtils.sendGet IOException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendGet IOException, url=" + url + ",param=" + param, e);
} }
catch (Exception e) catch (Exception e)
{ {
log.error("调用HttpsUtil.sendGet Exception, url=" + url + ",param=" + param, e); log.error("调用HttpsUtil.sendGet Exception, url=" + url + ",param=" + param, e);
} }
finally finally
{ {
try try
{ {
if (in != null) if (in != null)
{ {
in.close(); in.close();
} }
} }
catch (Exception ex) catch (Exception ex)
{ {
log.error("调用in.close Exception, url=" + url + ",param=" + param, ex); log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
} }
} }
return result.toString(); return result.toString();
} }
/** /**
* 向指定 URL 发送POST方法的请求 * 向指定 URL 发送POST方法的请求
* *
* @param url 发送请求的 URL * @param url 发送请求的 URL
* @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。 * @param param 请求参数，请求参数应该是 name1=value1&name2=value2 的形式。
* @return 所代表远程资源的响应结果 * @return 所代表远程资源的响应结果
*/ */
public static String sendPost(String url, String param) public static String sendPost(String url, String param)
{ {
PrintWriter out = null; PrintWriter out = null;
BufferedReader in = null; BufferedReader in = null;
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
try try
{ {
String urlNameString = url + "?" + param; String urlNameString = url + "?" + param;
log.info("sendPost - {}", urlNameString); log.info("sendPost - {}", urlNameString);
URL realUrl = new URL(urlNameString); URL realUrl = new URL(urlNameString);
URLConnection conn = realUrl.openConnection(); URLConnection conn = realUrl.openConnection();
conn.setRequestProperty("accept", "*/*"); conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive"); conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)"); conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
conn.setRequestProperty("Accept-Charset", "utf-8"); conn.setRequestProperty("Accept-Charset", "utf-8");
conn.setRequestProperty("contentType", "utf-8"); conn.setRequestProperty("contentType", "utf-8");
conn.setDoOutput(true); conn.setDoOutput(true);
conn.setDoInput(true); conn.setDoInput(true);
out = new PrintWriter(conn.getOutputStream()); out = new PrintWriter(conn.getOutputStream());
out.print(param); out.print(param);
out.flush(); out.flush();
in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8")); in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "utf-8"));
String line; String line;
while ((line = in.readLine()) != null) while ((line = in.readLine()) != null)
{ {
result.append(line); result.append(line);
} }
log.info("recv - {}", result); log.info("recv - {}", result);
} }
catch (ConnectException e) catch (ConnectException e)
{ {
log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendPost ConnectException, url=" + url + ",param=" + param, e);
} }
catch (SocketTimeoutException e) catch (SocketTimeoutException e)
{ {
log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendPost SocketTimeoutException, url=" + url + ",param=" + param, e);
} }
catch (IOException e) catch (IOException e)
{ {
log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendPost IOException, url=" + url + ",param=" + param, e);
} }
catch (Exception e) catch (Exception e)
{ {
log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e); log.error("调用HttpsUtil.sendPost Exception, url=" + url + ",param=" + param, e);
} }
finally finally
{ {
try try
{ {
if (out != null) if (out != null)
{ {
out.close(); out.close();
} }
if (in != null) if (in != null)
{ {
in.close(); in.close();
} }
} }
catch (IOException ex) catch (IOException ex)
{ {
log.error("调用in.close Exception, url=" + url + ",param=" + param, ex); log.error("调用in.close Exception, url=" + url + ",param=" + param, ex);
} }
} }
return result.toString(); return result.toString();
} }
public static String sendSSLPost(String url, String param) public static String sendSSLPost(String url, String param)
{ {
StringBuilder result = new StringBuilder(); StringBuilder result = new StringBuilder();
String urlNameString = url + "?" + param; String urlNameString = url + "?" + param;
try try
{ {
log.info("sendSSLPost - {}", urlNameString); log.info("sendSSLPost - {}", urlNameString);
SSLContext sc = SSLContext.getInstance("SSL"); SSLContext sc = SSLContext.getInstance("SSL");
sc.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom()); sc.init(null, new TrustManager[] { new TrustAnyTrustManager() }, new java.security.SecureRandom());
URL console = new URL(urlNameString); URL console = new URL(urlNameString);
HttpsURLConnection conn = (HttpsURLConnection) console.openConnection(); HttpsURLConnection conn = (HttpsURLConnection) console.openConnection();
conn.setRequestProperty("accept", "*/*"); conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive"); conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)"); conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
conn.setRequestProperty("Accept-Charset", "utf-8"); conn.setRequestProperty("Accept-Charset", "utf-8");
conn.setRequestProperty("contentType", "utf-8"); conn.setRequestProperty("contentType", "utf-8");
conn.setDoOutput(true); conn.setDoOutput(true);
conn.setDoInput(true); conn.setDoInput(true);
conn.setSSLSocketFactory(sc.getSocketFactory()); conn.setSSLSocketFactory(sc.getSocketFactory());
conn.setHostnameVerifier(new TrustAnyHostnameVerifier()); conn.setHostnameVerifier(new TrustAnyHostnameVerifier());
conn.connect(); conn.connect();
InputStream is = conn.getInputStream(); InputStream is = conn.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is)); BufferedReader br = new BufferedReader(new InputStreamReader(is));
String ret = ""; String ret = "";
while ((ret = br.readLine()) != null) while ((ret = br.readLine()) != null)
{ {
if (ret != null && !ret.trim().equals("")) if (ret != null && !ret.trim().equals(""))
{ {
result.append(new String(ret.getBytes("ISO-8859-1"), "utf-8")); result.append(new String(ret.getBytes("ISO-8859-1"), "utf-8"));
} }
} }
log.info("recv - {}", result); log.info("recv - {}", result);
conn.disconnect(); conn.disconnect();
br.close(); br.close();
} }
catch (ConnectException e) catch (ConnectException e)
{ {
log.error("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendSSLPost ConnectException, url=" + url + ",param=" + param, e);
} }
catch (SocketTimeoutException e) catch (SocketTimeoutException e)
{ {
log.error("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendSSLPost SocketTimeoutException, url=" + url + ",param=" + param, e);
} }
catch (IOException e) catch (IOException e)
{ {
log.error("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param, e); log.error("调用HttpUtils.sendSSLPost IOException, url=" + url + ",param=" + param, e);
} }
catch (Exception e) catch (Exception e)
{ {
log.error("调用HttpsUtil.sendSSLPost Exception, url=" + url + ",param=" + param, e); log.error("调用HttpsUtil.sendSSLPost Exception, url=" + url + ",param=" + param, e);
} }
return result.toString(); return result.toString();
} }
private static class TrustAnyTrustManager implements X509TrustManager private static class TrustAnyTrustManager implements X509TrustManager
{ {
@Override @Override
public void checkClientTrusted(X509Certificate[] chain, String authType) public void checkClientTrusted(X509Certificate[] chain, String authType)
{ {
} }
@Override @Override
public void checkServerTrusted(X509Certificate[] chain, String authType) public void checkServerTrusted(X509Certificate[] chain, String authType)
{ {
} }
@Override @Override
public X509Certificate[] getAcceptedIssuers() public X509Certificate[] getAcceptedIssuers()
{ {
return new X509Certificate[] {}; return new X509Certificate[] {};
} }
} }
private static class TrustAnyHostnameVerifier implements HostnameVerifier private static class TrustAnyHostnameVerifier implements HostnameVerifier
{ {
@Override @Override
public boolean verify(String hostname, SSLSession session) public boolean verify(String hostname, SSLSession session)
{ {
return true; return true;
} }
} }
} }

112
ruoyi/src/main/java/com/ruoyi/common/utils/ip/AddressUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/ip/AddressUtils.java
View File

@ -1,56 +1,56 @@
package com.ruoyi.common.utils.ip; package com.uvaluation.common.utils.ip;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.constant.Constants; import com.uvaluation.common.constant.Constants;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.http.HttpUtils; import com.uvaluation.common.utils.http.HttpUtils;
import com.ruoyi.framework.config.RuoYiConfig; import com.uvaluation.framework.config.RuoYiConfig;
/** /**
* 获取地址类 * 获取地址类
* *
* @author ruoyi * @author ruoyi
*/ */
public class AddressUtils public class AddressUtils
{ {
private static final Logger log = LoggerFactory.getLogger(AddressUtils.class); private static final Logger log = LoggerFactory.getLogger(AddressUtils.class);
// IP地址查询 // IP地址查询
public static final String IP_URL = "http://whois.pconline.com.cn/ipJson.jsp"; public static final String IP_URL = "http://whois.pconline.com.cn/ipJson.jsp";
// 未知地址 // 未知地址
public static final String UNKNOWN = "XX XX"; public static final String UNKNOWN = "XX XX";
public static String getRealAddressByIP(String ip) public static String getRealAddressByIP(String ip)
{ {
String address = UNKNOWN; String address = UNKNOWN;
// 内网不查询 // 内网不查询
if (IpUtils.internalIp(ip)) if (IpUtils.internalIp(ip))
{ {
return "内网IP"; return "内网IP";
} }
if (RuoYiConfig.isAddressEnabled()) if (RuoYiConfig.isAddressEnabled())
{ {
try try
{ {
String rspStr = HttpUtils.sendGet(IP_URL, "ip=" + ip + "&json=true", Constants.GBK); String rspStr = HttpUtils.sendGet(IP_URL, "ip=" + ip + "&json=true", Constants.GBK);
if (StringUtils.isEmpty(rspStr)) if (StringUtils.isEmpty(rspStr))
{ {
log.error("获取地理位置异常 {}", ip); log.error("获取地理位置异常 {}", ip);
return UNKNOWN; return UNKNOWN;
} }
JSONObject obj = JSONObject.parseObject(rspStr); JSONObject obj = JSONObject.parseObject(rspStr);
String region = obj.getString("pro"); String region = obj.getString("pro");
String city = obj.getString("city"); String city = obj.getString("city");
return String.format("%s %s", region, city); return String.format("%s %s", region, city);
} }
catch (Exception e) catch (Exception e)
{ {
log.error("获取地理位置异常 {}", ip); log.error("获取地理位置异常 {}", ip);
} }
} }
return address; return address;
} }
} }

376
ruoyi/src/main/java/com/ruoyi/common/utils/ip/IpUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/ip/IpUtils.java
View File

@ -1,189 +1,189 @@
package com.ruoyi.common.utils.ip; package com.uvaluation.common.utils.ip;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.UnknownHostException; import java.net.UnknownHostException;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* 获取IP方法 * 获取IP方法
* *
* @author ruoyi * @author ruoyi
*/ */
public class IpUtils public class IpUtils
{ {
public static String getIpAddr(HttpServletRequest request) public static String getIpAddr(HttpServletRequest request)
{ {
if (request == null) if (request == null)
{ {
return "unknown"; return "unknown";
} }
String ip = request.getHeader("x-forwarded-for"); String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{ {
ip = request.getHeader("Proxy-Client-IP"); ip = request.getHeader("Proxy-Client-IP");
} }
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{ {
ip = request.getHeader("X-Forwarded-For"); ip = request.getHeader("X-Forwarded-For");
} }
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{ {
ip = request.getHeader("WL-Proxy-Client-IP"); ip = request.getHeader("WL-Proxy-Client-IP");
} }
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{ {
ip = request.getHeader("X-Real-IP"); ip = request.getHeader("X-Real-IP");
} }
if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip))
{ {
ip = request.getRemoteAddr(); ip = request.getRemoteAddr();
} }
return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip; return "0:0:0:0:0:0:0:1".equals(ip) ? "127.0.0.1" : ip;
} }
public static boolean internalIp(String ip) public static boolean internalIp(String ip)
{ {
byte[] addr = textToNumericFormatV4(ip); byte[] addr = textToNumericFormatV4(ip);
return internalIp(addr) || "127.0.0.1".equals(ip); return internalIp(addr) || "127.0.0.1".equals(ip);
} }
private static boolean internalIp(byte[] addr) private static boolean internalIp(byte[] addr)
{ {
if (StringUtils.isNull(addr) || addr.length < 2) if (StringUtils.isNull(addr) || addr.length < 2)
{ {
return true; return true;
} }
final byte b0 = addr[0]; final byte b0 = addr[0];
final byte b1 = addr[1]; final byte b1 = addr[1];
// 10.x.x.x/8 // 10.x.x.x/8
final byte SECTION_1 = 0x0A; final byte SECTION_1 = 0x0A;
// 172.16.x.x/12 // 172.16.x.x/12
final byte SECTION_2 = (byte) 0xAC; final byte SECTION_2 = (byte) 0xAC;
final byte SECTION_3 = (byte) 0x10; final byte SECTION_3 = (byte) 0x10;
final byte SECTION_4 = (byte) 0x1F; final byte SECTION_4 = (byte) 0x1F;
// 192.168.x.x/16 // 192.168.x.x/16
final byte SECTION_5 = (byte) 0xC0; final byte SECTION_5 = (byte) 0xC0;
final byte SECTION_6 = (byte) 0xA8; final byte SECTION_6 = (byte) 0xA8;
switch (b0) switch (b0)
{ {
case SECTION_1: case SECTION_1:
return true; return true;
case SECTION_2: case SECTION_2:
if (b1 >= SECTION_3 && b1 <= SECTION_4) if (b1 >= SECTION_3 && b1 <= SECTION_4)
{ {
return true; return true;
} }
case SECTION_5: case SECTION_5:
switch (b1) switch (b1)
{ {
case SECTION_6: case SECTION_6:
return true; return true;
} }
default: default:
return false; return false;
} }
} }
/** /**
* 将IPv4地址转换成字节 * 将IPv4地址转换成字节
* *
* @param text IPv4地址 * @param text IPv4地址
* @return byte 字节 * @return byte 字节
*/ */
public static byte[] textToNumericFormatV4(String text) public static byte[] textToNumericFormatV4(String text)
{ {
if (text.length() == 0) if (text.length() == 0)
{ {
return null; return null;
} }
byte[] bytes = new byte[4]; byte[] bytes = new byte[4];
String[] elements = text.split("\\.", -1); String[] elements = text.split("\\.", -1);
try try
{ {
long l; long l;
int i; int i;
switch (elements.length) switch (elements.length)
{ {
case 1: case 1:
l = Long.parseLong(elements[0]); l = Long.parseLong(elements[0]);
if ((l < 0L) || (l > 4294967295L)) if ((l < 0L) || (l > 4294967295L))
return null; return null;
bytes[0] = (byte) (int) (l >> 24 & 0xFF); bytes[0] = (byte) (int) (l >> 24 & 0xFF);
bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF); bytes[1] = (byte) (int) ((l & 0xFFFFFF) >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF); bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF); bytes[3] = (byte) (int) (l & 0xFF);
break; break;
case 2: case 2:
l = Integer.parseInt(elements[0]); l = Integer.parseInt(elements[0]);
if ((l < 0L) || (l > 255L)) if ((l < 0L) || (l > 255L))
return null; return null;
bytes[0] = (byte) (int) (l & 0xFF); bytes[0] = (byte) (int) (l & 0xFF);
l = Integer.parseInt(elements[1]); l = Integer.parseInt(elements[1]);
if ((l < 0L) || (l > 16777215L)) if ((l < 0L) || (l > 16777215L))
return null; return null;
bytes[1] = (byte) (int) (l >> 16 & 0xFF); bytes[1] = (byte) (int) (l >> 16 & 0xFF);
bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF); bytes[2] = (byte) (int) ((l & 0xFFFF) >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF); bytes[3] = (byte) (int) (l & 0xFF);
break; break;
case 3: case 3:
for (i = 0; i < 2; ++i) for (i = 0; i < 2; ++i)
{ {
l = Integer.parseInt(elements[i]); l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L)) if ((l < 0L) || (l > 255L))
return null; return null;
bytes[i] = (byte) (int) (l & 0xFF); bytes[i] = (byte) (int) (l & 0xFF);
} }
l = Integer.parseInt(elements[2]); l = Integer.parseInt(elements[2]);
if ((l < 0L) || (l > 65535L)) if ((l < 0L) || (l > 65535L))
return null; return null;
bytes[2] = (byte) (int) (l >> 8 & 0xFF); bytes[2] = (byte) (int) (l >> 8 & 0xFF);
bytes[3] = (byte) (int) (l & 0xFF); bytes[3] = (byte) (int) (l & 0xFF);
break; break;
case 4: case 4:
for (i = 0; i < 4; ++i) for (i = 0; i < 4; ++i)
{ {
l = Integer.parseInt(elements[i]); l = Integer.parseInt(elements[i]);
if ((l < 0L) || (l > 255L)) if ((l < 0L) || (l > 255L))
return null; return null;
bytes[i] = (byte) (int) (l & 0xFF); bytes[i] = (byte) (int) (l & 0xFF);
} }
break; break;
default: default:
return null; return null;
} }
} }
catch (NumberFormatException e) catch (NumberFormatException e)
{ {
return null; return null;
} }
return bytes; return bytes;
} }
public static String getHostIp() public static String getHostIp()
{ {
try try
{ {
return InetAddress.getLocalHost().getHostAddress(); return InetAddress.getLocalHost().getHostAddress();
} }
catch (UnknownHostException e) catch (UnknownHostException e)
{ {
} }
return "127.0.0.1"; return "127.0.0.1";
} }
public static String getHostName() public static String getHostName()
{ {
try try
{ {
return InetAddress.getLocalHost().getHostName(); return InetAddress.getLocalHost().getHostName();
} }
catch (UnknownHostException e) catch (UnknownHostException e)
{ {
} }
return "未知"; return "未知";
} }
} }

20
ruoyi/src/main/java/com/ruoyi/common/utils/job/AbstractQuartzJob.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/AbstractQuartzJob.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import java.util.Date; import java.util.Date;
import org.quartz.Job; import org.quartz.Job;
@ -6,15 +6,15 @@ import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException; import org.quartz.JobExecutionException;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.ruoyi.common.constant.Constants; import com.uvaluation.common.constant.Constants;
import com.ruoyi.common.constant.ScheduleConstants; import com.uvaluation.common.constant.ScheduleConstants;
import com.ruoyi.common.utils.ExceptionUtil; import com.uvaluation.common.utils.ExceptionUtil;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils; import com.uvaluation.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.spring.SpringUtils; import com.uvaluation.common.utils.spring.SpringUtils;
import com.ruoyi.project.monitor.domain.SysJob; import com.uvaluation.project.monitor.domain.SysJob;
import com.ruoyi.project.monitor.domain.SysJobLog; import com.uvaluation.project.monitor.domain.SysJobLog;
import com.ruoyi.project.monitor.service.ISysJobLogService; import com.uvaluation.project.monitor.service.ISysJobLogService;
/** /**
* 抽象quartz调用 * 抽象quartz调用

2
ruoyi/src/main/java/com/ruoyi/common/utils/job/CronUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/CronUtils.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import java.text.ParseException; import java.text.ParseException;
import java.util.Date; import java.util.Date;

8
ruoyi/src/main/java/com/ruoyi/common/utils/job/JobInvokeUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/JobInvokeUtil.java
View File

@ -1,12 +1,12 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils; import com.uvaluation.common.utils.spring.SpringUtils;
import com.ruoyi.project.monitor.domain.SysJob; import com.uvaluation.project.monitor.domain.SysJob;
/** /**
* 任务执行工具 * 任务执行工具

4
ruoyi/src/main/java/com/ruoyi/common/utils/job/QuartzDisallowConcurrentExecution.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/QuartzDisallowConcurrentExecution.java
View File

@ -1,8 +1,8 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import org.quartz.DisallowConcurrentExecution; import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext; import org.quartz.JobExecutionContext;
import com.ruoyi.project.monitor.domain.SysJob; import com.uvaluation.project.monitor.domain.SysJob;
/** /**
* 定时任务处理（禁止并发执行） * 定时任务处理（禁止并发执行）

4
ruoyi/src/main/java/com/ruoyi/common/utils/job/QuartzJobExecution.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/QuartzJobExecution.java
View File

@ -1,7 +1,7 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import org.quartz.JobExecutionContext; import org.quartz.JobExecutionContext;
import com.ruoyi.project.monitor.domain.SysJob; import com.uvaluation.project.monitor.domain.SysJob;
/** /**
* 定时任务处理（允许并发执行） * 定时任务处理（允许并发执行）

10
ruoyi/src/main/java/com/ruoyi/common/utils/job/ScheduleUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/job/ScheduleUtils.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.job; package com.uvaluation.common.utils.job;
import org.quartz.CronScheduleBuilder; import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger; import org.quartz.CronTrigger;
@ -10,10 +10,10 @@ import org.quartz.Scheduler;
import org.quartz.SchedulerException; import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder; import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey; import org.quartz.TriggerKey;
import com.ruoyi.common.constant.ScheduleConstants; import com.uvaluation.common.constant.ScheduleConstants;
import com.ruoyi.common.exception.job.TaskException; import com.uvaluation.common.exception.job.TaskException;
import com.ruoyi.common.exception.job.TaskException.Code; import com.uvaluation.common.exception.job.TaskException.Code;
import com.ruoyi.project.monitor.domain.SysJob; import com.uvaluation.project.monitor.domain.SysJob;
/** /**
* 定时任务工具类 * 定时任务工具类

24
ruoyi/src/main/java/com/ruoyi/common/utils/poi/ExcelUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/poi/ExcelUtil.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.poi; package com.uvaluation.common.utils.poi;
import java.io.File; import java.io.File;
import java.io.FileOutputStream; import java.io.FileOutputStream;
@ -40,17 +40,17 @@ import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFDataValidation; import org.apache.poi.xssf.usermodel.XSSFDataValidation;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.ruoyi.framework.aspectj.lang.annotation.Excel; import com.uvaluation.framework.aspectj.lang.annotation.Excel;
import com.ruoyi.framework.aspectj.lang.annotation.Excel.ColumnType; import com.uvaluation.framework.aspectj.lang.annotation.Excel.ColumnType;
import com.ruoyi.framework.aspectj.lang.annotation.Excel.Type; import com.uvaluation.framework.aspectj.lang.annotation.Excel.Type;
import com.ruoyi.framework.aspectj.lang.annotation.Excels; import com.uvaluation.framework.aspectj.lang.annotation.Excels;
import com.ruoyi.framework.config.RuoYiConfig; import com.uvaluation.framework.config.RuoYiConfig;
import com.ruoyi.framework.web.domain.AjaxResult; import com.uvaluation.framework.web.domain.AjaxResult;
import com.ruoyi.common.core.text.Convert; import com.uvaluation.common.core.text.Convert;
import com.ruoyi.common.exception.CustomException; import com.uvaluation.common.exception.CustomException;
import com.ruoyi.common.utils.DateUtils; import com.uvaluation.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.reflect.ReflectUtils; import com.uvaluation.common.utils.reflect.ReflectUtils;
/** /**
* Excel相关处理 * Excel相关处理

7
ruoyi/src/main/java/com/ruoyi/common/utils/reflect/ReflectUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/reflect/ReflectUtils.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.common.utils.reflect; package com.uvaluation.common.utils.reflect;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException; import java.lang.reflect.InvocationTargetException;
@ -8,14 +8,13 @@ import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type; import java.lang.reflect.Type;
import java.util.Date; import java.util.Date;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate; import org.apache.commons.lang3.Validate;
import org.apache.poi.ss.usermodel.DateUtil; import org.apache.poi.ss.usermodel.DateUtil;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import com.ruoyi.common.core.text.Convert; import com.uvaluation.common.core.text.Convert;
import com.ruoyi.common.utils.DateUtils; import com.uvaluation.common.utils.DateUtils;
/** /**
* 反射工具类. 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数. * 反射工具类. 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.

132
ruoyi/src/main/java/com/ruoyi/common/utils/security/Md5Utils.java → ruoyi/src/main/java/com/uvaluation/common/utils/security/Md5Utils.java
View File

@ -1,66 +1,66 @@
package com.ruoyi.common.utils.security; package com.uvaluation.common.utils.security;
import java.security.MessageDigest; import java.security.MessageDigest;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
/** /**
* Md5加密方法 * Md5加密方法
* *
* @author ruoyi * @author ruoyi
*/ */
public class Md5Utils public class Md5Utils
{ {
private static final Logger log = LoggerFactory.getLogger(Md5Utils.class); private static final Logger log = LoggerFactory.getLogger(Md5Utils.class);
private static byte[] md5(String s) private static byte[] md5(String s)
{ {
MessageDigest algorithm; MessageDigest algorithm;
try try
{ {
algorithm = MessageDigest.getInstance("MD5"); algorithm = MessageDigest.getInstance("MD5");
algorithm.reset(); algorithm.reset();
algorithm.update(s.getBytes("UTF-8")); algorithm.update(s.getBytes("UTF-8"));
byte[] messageDigest = algorithm.digest(); byte[] messageDigest = algorithm.digest();
return messageDigest; return messageDigest;
} }
catch (Exception e) catch (Exception e)
{ {
log.error("MD5 Error...", e); log.error("MD5 Error...", e);
} }
return null; return null;
} }
private static final String toHex(byte hash[]) private static final String toHex(byte hash[])
{ {
if (hash == null) if (hash == null)
{ {
return null; return null;
} }
StringBuffer buf = new StringBuffer(hash.length * 2); StringBuffer buf = new StringBuffer(hash.length * 2);
int i; int i;
for (i = 0; i < hash.length; i++) for (i = 0; i < hash.length; i++)
{ {
if ((hash[i] & 0xff) < 0x10) if ((hash[i] & 0xff) < 0x10)
{ {
buf.append("0"); buf.append("0");
} }
buf.append(Long.toString(hash[i] & 0xff, 16)); buf.append(Long.toString(hash[i] & 0xff, 16));
} }
return buf.toString(); return buf.toString();
} }
public static String hash(String s) public static String hash(String s)
{ {
try try
{ {
return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8"); return new String(toHex(md5(s)).getBytes("UTF-8"), "UTF-8");
} }
catch (Exception e) catch (Exception e)
{ {
log.error("not supported charset...{}", e); log.error("not supported charset...{}", e);
return s; return s;
} }
} }
} }

582
ruoyi/src/main/java/com/ruoyi/common/utils/sign/Base64.java → ruoyi/src/main/java/com/uvaluation/common/utils/sign/Base64.java
View File

@ -1,291 +1,291 @@
package com.ruoyi.common.utils.sign; package com.uvaluation.common.utils.sign;
/** /**
* Base64工具类 * Base64工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public final class Base64 public final class Base64
{ {
static private final int BASELENGTH = 128; static private final int BASELENGTH = 128;
static private final int LOOKUPLENGTH = 64; static private final int LOOKUPLENGTH = 64;
static private final int TWENTYFOURBITGROUP = 24; static private final int TWENTYFOURBITGROUP = 24;
static private final int EIGHTBIT = 8; static private final int EIGHTBIT = 8;
static private final int SIXTEENBIT = 16; static private final int SIXTEENBIT = 16;
static private final int FOURBYTE = 4; static private final int FOURBYTE = 4;
static private final int SIGN = -128; static private final int SIGN = -128;
static private final char PAD = '='; static private final char PAD = '=';
static final private byte[] base64Alphabet = new byte[BASELENGTH]; static final private byte[] base64Alphabet = new byte[BASELENGTH];
static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH]; static final private char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];
static static
{ {
for (int i = 0; i < BASELENGTH; ++i) for (int i = 0; i < BASELENGTH; ++i)
{ {
base64Alphabet[i] = -1; base64Alphabet[i] = -1;
} }
for (int i = 'Z'; i >= 'A'; i--) for (int i = 'Z'; i >= 'A'; i--)
{ {
base64Alphabet[i] = (byte) (i - 'A'); base64Alphabet[i] = (byte) (i - 'A');
} }
for (int i = 'z'; i >= 'a'; i--) for (int i = 'z'; i >= 'a'; i--)
{ {
base64Alphabet[i] = (byte) (i - 'a' + 26); base64Alphabet[i] = (byte) (i - 'a' + 26);
} }
for (int i = '9'; i >= '0'; i--) for (int i = '9'; i >= '0'; i--)
{ {
base64Alphabet[i] = (byte) (i - '0' + 52); base64Alphabet[i] = (byte) (i - '0' + 52);
} }
base64Alphabet['+'] = 62; base64Alphabet['+'] = 62;
base64Alphabet['/'] = 63; base64Alphabet['/'] = 63;
for (int i = 0; i <= 25; i++) for (int i = 0; i <= 25; i++)
{ {
lookUpBase64Alphabet[i] = (char) ('A' + i); lookUpBase64Alphabet[i] = (char) ('A' + i);
} }
for (int i = 26, j = 0; i <= 51; i++, j++) for (int i = 26, j = 0; i <= 51; i++, j++)
{ {
lookUpBase64Alphabet[i] = (char) ('a' + j); lookUpBase64Alphabet[i] = (char) ('a' + j);
} }
for (int i = 52, j = 0; i <= 61; i++, j++) for (int i = 52, j = 0; i <= 61; i++, j++)
{ {
lookUpBase64Alphabet[i] = (char) ('0' + j); lookUpBase64Alphabet[i] = (char) ('0' + j);
} }
lookUpBase64Alphabet[62] = (char) '+'; lookUpBase64Alphabet[62] = (char) '+';
lookUpBase64Alphabet[63] = (char) '/'; lookUpBase64Alphabet[63] = (char) '/';
} }
private static boolean isWhiteSpace(char octect) private static boolean isWhiteSpace(char octect)
{ {
return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9); return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
} }
private static boolean isPad(char octect) private static boolean isPad(char octect)
{ {
return (octect == PAD); return (octect == PAD);
} }
private static boolean isData(char octect) private static boolean isData(char octect)
{ {
return (octect < BASELENGTH && base64Alphabet[octect] != -1); return (octect < BASELENGTH && base64Alphabet[octect] != -1);
} }
/** /**
* Encodes hex octects into Base64 * Encodes hex octects into Base64
* *
* @param binaryData Array containing binaryData * @param binaryData Array containing binaryData
* @return Encoded Base64 array * @return Encoded Base64 array
*/ */
public static String encode(byte[] binaryData) public static String encode(byte[] binaryData)
{ {
if (binaryData == null) if (binaryData == null)
{ {
return null; return null;
} }
int lengthDataBits = binaryData.length * EIGHTBIT; int lengthDataBits = binaryData.length * EIGHTBIT;
if (lengthDataBits == 0) if (lengthDataBits == 0)
{ {
return ""; return "";
} }
int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP; int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP; int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets; int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
char encodedData[] = null; char encodedData[] = null;
encodedData = new char[numberQuartet * 4]; encodedData = new char[numberQuartet * 4];
byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0; byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
int encodedIndex = 0; int encodedIndex = 0;
int dataIndex = 0; int dataIndex = 0;
for (int i = 0; i < numberTriplets; i++) for (int i = 0; i < numberTriplets; i++)
{ {
b1 = binaryData[dataIndex++]; b1 = binaryData[dataIndex++];
b2 = binaryData[dataIndex++]; b2 = binaryData[dataIndex++];
b3 = binaryData[dataIndex++]; b3 = binaryData[dataIndex++];
l = (byte) (b2 & 0x0f); l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03); k = (byte) (b1 & 0x03);
byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc); byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);
encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3]; encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f]; encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
} }
// form integral number of 6-bit groups // form integral number of 6-bit groups
if (fewerThan24bits == EIGHTBIT) if (fewerThan24bits == EIGHTBIT)
{ {
b1 = binaryData[dataIndex]; b1 = binaryData[dataIndex];
k = (byte) (b1 & 0x03); k = (byte) (b1 & 0x03);
byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4]; encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
encodedData[encodedIndex++] = PAD; encodedData[encodedIndex++] = PAD;
encodedData[encodedIndex++] = PAD; encodedData[encodedIndex++] = PAD;
} }
else if (fewerThan24bits == SIXTEENBIT) else if (fewerThan24bits == SIXTEENBIT)
{ {
b1 = binaryData[dataIndex]; b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1]; b2 = binaryData[dataIndex + 1];
l = (byte) (b2 & 0x0f); l = (byte) (b2 & 0x0f);
k = (byte) (b1 & 0x03); k = (byte) (b1 & 0x03);
byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0); byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0); byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
encodedData[encodedIndex++] = lookUpBase64Alphabet[val1]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)]; encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2]; encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
encodedData[encodedIndex++] = PAD; encodedData[encodedIndex++] = PAD;
} }
return new String(encodedData); return new String(encodedData);
} }
/** /**
* Decodes Base64 data into octects * Decodes Base64 data into octects
* *
* @param encoded string containing Base64 data * @param encoded string containing Base64 data
* @return Array containind decoded data. * @return Array containind decoded data.
*/ */
public static byte[] decode(String encoded) public static byte[] decode(String encoded)
{ {
if (encoded == null) if (encoded == null)
{ {
return null; return null;
} }
char[] base64Data = encoded.toCharArray(); char[] base64Data = encoded.toCharArray();
// remove white spaces // remove white spaces
int len = removeWhiteSpace(base64Data); int len = removeWhiteSpace(base64Data);
if (len % FOURBYTE != 0) if (len % FOURBYTE != 0)
{ {
return null;// should be divisible by four return null;// should be divisible by four
} }
int numberQuadruple = (len / FOURBYTE); int numberQuadruple = (len / FOURBYTE);
if (numberQuadruple == 0) if (numberQuadruple == 0)
{ {
return new byte[0]; return new byte[0];
} }
byte decodedData[] = null; byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0; byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
char d1 = 0, d2 = 0, d3 = 0, d4 = 0; char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
int i = 0; int i = 0;
int encodedIndex = 0; int encodedIndex = 0;
int dataIndex = 0; int dataIndex = 0;
decodedData = new byte[(numberQuadruple) * 3]; decodedData = new byte[(numberQuadruple) * 3];
for (; i < numberQuadruple - 1; i++) for (; i < numberQuadruple - 1; i++)
{ {
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])) if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
|| !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) || !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++])))
{ {
return null; return null;
} // if found "no data" just return null } // if found "no data" just return null
b1 = base64Alphabet[d1]; b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2]; b2 = base64Alphabet[d2];
b3 = base64Alphabet[d3]; b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4]; b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
} }
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])))
{ {
return null;// if found "no data" just return null return null;// if found "no data" just return null
} }
b1 = base64Alphabet[d1]; b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2]; b2 = base64Alphabet[d2];
d3 = base64Data[dataIndex++]; d3 = base64Data[dataIndex++];
d4 = base64Data[dataIndex++]; d4 = base64Data[dataIndex++];
if (!isData((d3)) || !isData((d4))) if (!isData((d3)) || !isData((d4)))
{// Check if they are PAD characters {// Check if they are PAD characters
if (isPad(d3) && isPad(d4)) if (isPad(d3) && isPad(d4))
{ {
if ((b2 & 0xf) != 0)// last 4 bits should be zero if ((b2 & 0xf) != 0)// last 4 bits should be zero
{ {
return null; return null;
} }
byte[] tmp = new byte[i * 3 + 1]; byte[] tmp = new byte[i * 3 + 1];
System.arraycopy(decodedData, 0, tmp, 0, i * 3); System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
return tmp; return tmp;
} }
else if (!isPad(d3) && isPad(d4)) else if (!isPad(d3) && isPad(d4))
{ {
b3 = base64Alphabet[d3]; b3 = base64Alphabet[d3];
if ((b3 & 0x3) != 0)// last 2 bits should be zero if ((b3 & 0x3) != 0)// last 2 bits should be zero
{ {
return null; return null;
} }
byte[] tmp = new byte[i * 3 + 2]; byte[] tmp = new byte[i * 3 + 2];
System.arraycopy(decodedData, 0, tmp, 0, i * 3); System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
return tmp; return tmp;
} }
else else
{ {
return null; return null;
} }
} }
else else
{ // No PAD e.g 3cQl { // No PAD e.g 3cQl
b3 = base64Alphabet[d3]; b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4]; b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4); decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte) (b3 << 6 | b4); decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
} }
return decodedData; return decodedData;
} }
/** /**
* remove WhiteSpace from MIME containing encoded Base64 data. * remove WhiteSpace from MIME containing encoded Base64 data.
* *
* @param data the byte array of base64 data (with WS) * @param data the byte array of base64 data (with WS)
* @return the new length * @return the new length
*/ */
private static int removeWhiteSpace(char[] data) private static int removeWhiteSpace(char[] data)
{ {
if (data == null) if (data == null)
{ {
return 0; return 0;
} }
// count characters that's not whitespace // count characters that's not whitespace
int newSize = 0; int newSize = 0;
int len = data.length; int len = data.length;
for (int i = 0; i < len; i++) for (int i = 0; i < len; i++)
{ {
if (!isWhiteSpace(data[i])) if (!isWhiteSpace(data[i]))
{ {
data[newSize++] = data[i]; data[newSize++] = data[i];
} }
} }
return newSize; return newSize;
} }
} }

228
ruoyi/src/main/java/com/ruoyi/common/utils/spring/SpringUtils.java → ruoyi/src/main/java/com/uvaluation/common/utils/spring/SpringUtils.java
View File

@ -1,114 +1,114 @@
package com.ruoyi.common.utils.spring; package com.uvaluation.common.utils.spring;
import org.springframework.aop.framework.AopContext; import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException; import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException; import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor; import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory; import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
/** /**
* spring工具类 方便在非spring管理环境中获取bean * spring工具类 方便在非spring管理环境中获取bean
* *
* @author ruoyi * @author ruoyi
*/ */
@Component @Component
public final class SpringUtils implements BeanFactoryPostProcessor public final class SpringUtils implements BeanFactoryPostProcessor
{ {
/** Spring应用上下文环境 */ /** Spring应用上下文环境 */
private static ConfigurableListableBeanFactory beanFactory; private static ConfigurableListableBeanFactory beanFactory;
@Override @Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
{ {
SpringUtils.beanFactory = beanFactory; SpringUtils.beanFactory = beanFactory;
} }
/** /**
* 获取对象 * 获取对象
* *
* @param name * @param name
* @return Object 一个以所给名字注册的bean的实例 * @return Object 一个以所给名字注册的bean的实例
* @throws org.springframework.beans.BeansException * @throws org.springframework.beans.BeansException
* *
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static <T> T getBean(String name) throws BeansException public static <T> T getBean(String name) throws BeansException
{ {
return (T) beanFactory.getBean(name); return (T) beanFactory.getBean(name);
} }
/** /**
* 获取类型为requiredType的对象 * 获取类型为requiredType的对象
* *
* @param clz * @param clz
* @return * @return
* @throws org.springframework.beans.BeansException * @throws org.springframework.beans.BeansException
* *
*/ */
public static <T> T getBean(Class<T> clz) throws BeansException public static <T> T getBean(Class<T> clz) throws BeansException
{ {
T result = (T) beanFactory.getBean(clz); T result = (T) beanFactory.getBean(clz);
return result; return result;
} }
/** /**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
* *
* @param name * @param name
* @return boolean * @return boolean
*/ */
public static boolean containsBean(String name) public static boolean containsBean(String name)
{ {
return beanFactory.containsBean(name); return beanFactory.containsBean(name);
} }
/** /**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException） * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
* *
* @param name * @param name
* @return boolean * @return boolean
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
* *
*/ */
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
{ {
return beanFactory.isSingleton(name); return beanFactory.isSingleton(name);
} }
/** /**
* @param name * @param name
* @return Class 注册对象的类型 * @return Class 注册对象的类型
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
* *
*/ */
public static Class<?> getType(String name) throws NoSuchBeanDefinitionException public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
{ {
return beanFactory.getType(name); return beanFactory.getType(name);
} }
/** /**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名 * 如果给定的bean名字在bean定义中有别名，则返回这些别名
* *
* @param name * @param name
* @return * @return
* @throws org.springframework.beans.factory.NoSuchBeanDefinitionException * @throws org.springframework.beans.factory.NoSuchBeanDefinitionException
* *
*/ */
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
{ {
return beanFactory.getAliases(name); return beanFactory.getAliases(name);
} }
/** /**
* 获取aop代理对象 * 获取aop代理对象
* *
* @param invoker * @param invoker
* @return * @return
*/ */
@SuppressWarnings("unchecked") @SuppressWarnings("unchecked")
public static <T> T getAopProxy(T invoker) public static <T> T getAopProxy(T invoker)
{ {
return (T) AopContext.currentProxy(); return (T) AopContext.currentProxy();
} }
} }

72
ruoyi/src/main/java/com/ruoyi/common/utils/sql/SqlUtil.java → ruoyi/src/main/java/com/uvaluation/common/utils/sql/SqlUtil.java
View File

@ -1,36 +1,36 @@
package com.ruoyi.common.utils.sql; package com.uvaluation.common.utils.sql;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* sql操作工具类 * sql操作工具类
* *
* @author ruoyi * @author ruoyi
*/ */
public class SqlUtil public class SqlUtil
{ {
/** /**
* 仅支持字母、数字、下划线、空格、逗号（支持多个字段排序） * 仅支持字母、数字、下划线、空格、逗号（支持多个字段排序）
*/ */
public static String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,]+"; public static String SQL_PATTERN = "[a-zA-Z0-9_\\ \\,]+";
/** /**
* 检查字符，防止注入绕过 * 检查字符，防止注入绕过
*/ */
public static String escapeOrderBySql(String value) public static String escapeOrderBySql(String value)
{ {
if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value)) if (StringUtils.isNotEmpty(value) && !isValidOrderBySql(value))
{ {
return StringUtils.EMPTY; return StringUtils.EMPTY;
} }
return value; return value;
} }
/** /**
* 验证 order by 语法是否符合规范 * 验证 order by 语法是否符合规范
*/ */
public static boolean isValidOrderBySql(String value) public static boolean isValidOrderBySql(String value)
{ {
return value.matches(SQL_PATTERN); return value.matches(SQL_PATTERN);
} }
} }

320
ruoyi/src/main/java/com/ruoyi/framework/aspectj/DataScopeAspect.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/DataScopeAspect.java
View File

@ -1,160 +1,160 @@
package com.ruoyi.framework.aspectj; package com.uvaluation.framework.aspectj;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import org.aspectj.lang.JoinPoint; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature; import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature; import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.ServletUtils; import com.uvaluation.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.spring.SpringUtils; import com.uvaluation.common.utils.spring.SpringUtils;
import com.ruoyi.framework.aspectj.lang.annotation.DataScope; import com.uvaluation.framework.aspectj.lang.annotation.DataScope;
import com.ruoyi.framework.security.LoginUser; import com.uvaluation.framework.security.LoginUser;
import com.ruoyi.framework.security.service.TokenService; import com.uvaluation.framework.security.service.TokenService;
import com.ruoyi.framework.web.domain.BaseEntity; import com.uvaluation.framework.web.domain.BaseEntity;
import com.ruoyi.project.system.domain.SysRole; import com.uvaluation.project.system.domain.SysRole;
import com.ruoyi.project.system.domain.SysUser; import com.uvaluation.project.system.domain.SysUser;
/** /**
* 数据过滤处理 * 数据过滤处理
* *
* @author ruoyi * @author ruoyi
*/ */
@Aspect @Aspect
@Component @Component
public class DataScopeAspect public class DataScopeAspect
{ {
/** /**
* 全部数据权限 * 全部数据权限
*/ */
public static final String DATA_SCOPE_ALL = "1"; public static final String DATA_SCOPE_ALL = "1";
/** /**
* 自定数据权限 * 自定数据权限
*/ */
public static final String DATA_SCOPE_CUSTOM = "2"; public static final String DATA_SCOPE_CUSTOM = "2";
/** /**
* 部门数据权限 * 部门数据权限
*/ */
public static final String DATA_SCOPE_DEPT = "3"; public static final String DATA_SCOPE_DEPT = "3";
/** /**
* 部门及以下数据权限 * 部门及以下数据权限
*/ */
public static final String DATA_SCOPE_DEPT_AND_CHILD = "4"; public static final String DATA_SCOPE_DEPT_AND_CHILD = "4";
/** /**
* 仅本人数据权限 * 仅本人数据权限
*/ */
public static final String DATA_SCOPE_SELF = "5"; public static final String DATA_SCOPE_SELF = "5";
// 配置织入点 // 配置织入点
@Pointcut("@annotation(com.ruoyi.framework.aspectj.lang.annotation.DataScope)") @Pointcut("@annotation(com.uvaluation.framework.aspectj.lang.annotation.DataScope)")
public void dataScopePointCut() public void dataScopePointCut()
{ {
} }
@Before("dataScopePointCut()") @Before("dataScopePointCut()")
public void doBefore(JoinPoint point) throws Throwable public void doBefore(JoinPoint point) throws Throwable
{ {
handleDataScope(point); handleDataScope(point);
} }
protected void handleDataScope(final JoinPoint joinPoint) protected void handleDataScope(final JoinPoint joinPoint)
{ {
// 获得注解 // 获得注解
DataScope controllerDataScope = getAnnotationLog(joinPoint); DataScope controllerDataScope = getAnnotationLog(joinPoint);
if (controllerDataScope == null) if (controllerDataScope == null)
{ {
return; return;
} }
// 获取当前的用户 // 获取当前的用户
LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest()); LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest());
SysUser currentUser = loginUser.getUser(); SysUser currentUser = loginUser.getUser();
if (currentUser != null) if (currentUser != null)
{ {
// 如果是超级管理员，则不过滤数据 // 如果是超级管理员，则不过滤数据
if (!currentUser.isAdmin()) if (!currentUser.isAdmin())
{ {
dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(), dataScopeFilter(joinPoint, currentUser, controllerDataScope.deptAlias(),
controllerDataScope.userAlias()); controllerDataScope.userAlias());
} }
} }
} }
/** /**
* 数据范围过滤 * 数据范围过滤
* *
* @param joinPoint 切点 * @param joinPoint 切点
* @param user 用户 * @param user 用户
* @param alias 别名 * @param alias 别名
*/ */
public static void dataScopeFilter(JoinPoint joinPoint, SysUser user, String deptAlias, String userAlias) public static void dataScopeFilter(JoinPoint joinPoint, SysUser user, String deptAlias, String userAlias)
{ {
StringBuilder sqlString = new StringBuilder(); StringBuilder sqlString = new StringBuilder();
for (SysRole role : user.getRoles()) for (SysRole role : user.getRoles())
{ {
String dataScope = role.getDataScope(); String dataScope = role.getDataScope();
if (DATA_SCOPE_ALL.equals(dataScope)) if (DATA_SCOPE_ALL.equals(dataScope))
{ {
sqlString = new StringBuilder(); sqlString = new StringBuilder();
break; break;
} }
else if (DATA_SCOPE_CUSTOM.equals(dataScope)) else if (DATA_SCOPE_CUSTOM.equals(dataScope))
{ {
sqlString.append(StringUtils.format( sqlString.append(StringUtils.format(
" OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias, " OR {}.dept_id IN ( SELECT dept_id FROM sys_role_dept WHERE role_id = {} ) ", deptAlias,
role.getRoleId())); role.getRoleId()));
} }
else if (DATA_SCOPE_DEPT.equals(dataScope)) else if (DATA_SCOPE_DEPT.equals(dataScope))
{ {
sqlString.append(StringUtils.format(" OR {}.dept_id = {} ", deptAlias, user.getDeptId())); sqlString.append(StringUtils.format(" OR {}.dept_id = {} ", deptAlias, user.getDeptId()));
} }
else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope)) else if (DATA_SCOPE_DEPT_AND_CHILD.equals(dataScope))
{ {
sqlString.append(StringUtils.format( sqlString.append(StringUtils.format(
" OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )", " OR {}.dept_id IN ( SELECT dept_id FROM sys_dept WHERE dept_id = {} or find_in_set( {} , ancestors ) )",
deptAlias, user.getDeptId(), user.getDeptId())); deptAlias, user.getDeptId(), user.getDeptId()));
} }
else if (DATA_SCOPE_SELF.equals(dataScope)) else if (DATA_SCOPE_SELF.equals(dataScope))
{ {
if (StringUtils.isNotBlank(userAlias)) if (StringUtils.isNotBlank(userAlias))
{ {
sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId())); sqlString.append(StringUtils.format(" OR {}.user_id = {} ", userAlias, user.getUserId()));
} }
else else
{ {
// 数据权限为仅本人且没有userAlias别名不查询任何数据 // 数据权限为仅本人且没有userAlias别名不查询任何数据
sqlString.append(" OR 1=0 "); sqlString.append(" OR 1=0 ");
} }
} }
} }
if (StringUtils.isNotBlank(sqlString.toString())) if (StringUtils.isNotBlank(sqlString.toString()))
{ {
BaseEntity baseEntity = (BaseEntity) joinPoint.getArgs()[0]; BaseEntity baseEntity = (BaseEntity) joinPoint.getArgs()[0];
baseEntity.setDataScope(" AND (" + sqlString.substring(4) + ")"); baseEntity.setDataScope(" AND (" + sqlString.substring(4) + ")");
} }
} }
/** /**
* 是否存在注解，如果存在就获取 * 是否存在注解，如果存在就获取
*/ */
private DataScope getAnnotationLog(JoinPoint joinPoint) private DataScope getAnnotationLog(JoinPoint joinPoint)
{ {
Signature signature = joinPoint.getSignature(); Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature; MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod(); Method method = methodSignature.getMethod();
if (method != null) if (method != null)
{ {
return method.getAnnotation(DataScope.class); return method.getAnnotation(DataScope.class);
} }
return null; return null;
} }
} }

144
ruoyi/src/main/java/com/ruoyi/framework/aspectj/DataSourceAspect.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/DataSourceAspect.java
View File

@ -1,72 +1,72 @@
package com.ruoyi.framework.aspectj; package com.uvaluation.framework.aspectj;
import java.util.Objects; import java.util.Objects;
import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature; import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.AnnotationUtils; import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.core.annotation.Order; import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.framework.aspectj.lang.annotation.DataSource; import com.uvaluation.framework.aspectj.lang.annotation.DataSource;
import com.ruoyi.framework.datasource.DynamicDataSourceContextHolder; import com.uvaluation.framework.datasource.DynamicDataSourceContextHolder;
/** /**
* 多数据源处理 * 多数据源处理
* *
* @author ruoyi * @author ruoyi
*/ */
@Aspect @Aspect
@Order(1) @Order(1)
@Component @Component
public class DataSourceAspect public class DataSourceAspect
{ {
protected Logger logger = LoggerFactory.getLogger(getClass()); protected Logger logger = LoggerFactory.getLogger(getClass());
@Pointcut("@annotation(com.ruoyi.framework.aspectj.lang.annotation.DataSource)" @Pointcut("@annotation(com.uvaluation.framework.aspectj.lang.annotation.DataSource)"
+ "|| @within(com.ruoyi.framework.aspectj.lang.annotation.DataSource)") + "|| @within(com.uvaluation.framework.aspectj.lang.annotation.DataSource)")
public void dsPointCut() public void dsPointCut()
{ {
} }
@Around("dsPointCut()") @Around("dsPointCut()")
public Object around(ProceedingJoinPoint point) throws Throwable public Object around(ProceedingJoinPoint point) throws Throwable
{ {
DataSource dataSource = getDataSource(point); DataSource dataSource = getDataSource(point);
if (StringUtils.isNotNull(dataSource)) if (StringUtils.isNotNull(dataSource))
{ {
DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name()); DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
} }
try try
{ {
return point.proceed(); return point.proceed();
} }
finally finally
{ {
// 销毁数据源 在执行方法之后 // 销毁数据源 在执行方法之后
DynamicDataSourceContextHolder.clearDataSourceType(); DynamicDataSourceContextHolder.clearDataSourceType();
} }
} }
/** /**
* 获取需要切换的数据源 * 获取需要切换的数据源
*/ */
public DataSource getDataSource(ProceedingJoinPoint point) public DataSource getDataSource(ProceedingJoinPoint point)
{ {
MethodSignature signature = (MethodSignature) point.getSignature(); MethodSignature signature = (MethodSignature) point.getSignature();
DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class); DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), DataSource.class);
if (Objects.nonNull(dataSource)) if (Objects.nonNull(dataSource))
{ {
return dataSource; return dataSource;
} }
return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class); return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
} }
} }

434
ruoyi/src/main/java/com/ruoyi/framework/aspectj/LogAspect.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/LogAspect.java
View File

@ -1,217 +1,217 @@
package com.ruoyi.framework.aspectj; package com.uvaluation.framework.aspectj;
import java.lang.reflect.Method; import java.lang.reflect.Method;
import java.util.Map; import java.util.Map;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import org.aspectj.lang.JoinPoint; import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.Signature; import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature; import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger; import org.slf4j.Logger;
import org.slf4j.LoggerFactory; import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile; import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.HandlerMapping; import org.springframework.web.servlet.HandlerMapping;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.ruoyi.common.enums.HttpMethod; import com.uvaluation.common.enums.HttpMethod;
import com.ruoyi.common.utils.ServletUtils; import com.uvaluation.common.utils.ServletUtils;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
import com.ruoyi.common.utils.ip.IpUtils; import com.uvaluation.common.utils.ip.IpUtils;
import com.ruoyi.common.utils.spring.SpringUtils; import com.uvaluation.common.utils.spring.SpringUtils;
import com.ruoyi.framework.aspectj.lang.annotation.Log; import com.uvaluation.framework.aspectj.lang.annotation.Log;
import com.ruoyi.framework.aspectj.lang.enums.BusinessStatus; import com.uvaluation.framework.aspectj.lang.enums.BusinessStatus;
import com.ruoyi.framework.manager.AsyncManager; import com.uvaluation.framework.manager.AsyncManager;
import com.ruoyi.framework.manager.factory.AsyncFactory; import com.uvaluation.framework.manager.factory.AsyncFactory;
import com.ruoyi.framework.security.LoginUser; import com.uvaluation.framework.security.LoginUser;
import com.ruoyi.framework.security.service.TokenService; import com.uvaluation.framework.security.service.TokenService;
import com.ruoyi.project.monitor.domain.SysOperLog; import com.uvaluation.project.monitor.domain.SysOperLog;
/** /**
* 操作日志记录处理 * 操作日志记录处理
* *
* @author ruoyi * @author ruoyi
*/ */
@Aspect @Aspect
@Component @Component
public class LogAspect public class LogAspect
{ {
private static final Logger log = LoggerFactory.getLogger(LogAspect.class); private static final Logger log = LoggerFactory.getLogger(LogAspect.class);
// 配置织入点 // 配置织入点
@Pointcut("@annotation(com.ruoyi.framework.aspectj.lang.annotation.Log)") @Pointcut("@annotation(com.uvaluation.framework.aspectj.lang.annotation.Log)")
public void logPointCut() public void logPointCut()
{ {
} }
/** /**
* 处理完请求后执行 * 处理完请求后执行
* *
* @param joinPoint 切点 * @param joinPoint 切点
*/ */
@AfterReturning(pointcut = "logPointCut()", returning = "jsonResult") @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) public void doAfterReturning(JoinPoint joinPoint, Object jsonResult)
{ {
handleLog(joinPoint, null, jsonResult); handleLog(joinPoint, null, jsonResult);
} }
/** /**
* 拦截异常操作 * 拦截异常操作
* *
* @param joinPoint 切点 * @param joinPoint 切点
* @param e 异常 * @param e 异常
*/ */
@AfterThrowing(value = "logPointCut()", throwing = "e") @AfterThrowing(value = "logPointCut()", throwing = "e")
public void doAfterThrowing(JoinPoint joinPoint, Exception e) public void doAfterThrowing(JoinPoint joinPoint, Exception e)
{ {
handleLog(joinPoint, e, null); handleLog(joinPoint, e, null);
} }
protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult) protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult)
{ {
try try
{ {
// 获得注解 // 获得注解
Log controllerLog = getAnnotationLog(joinPoint); Log controllerLog = getAnnotationLog(joinPoint);
if (controllerLog == null) if (controllerLog == null)
{ {
return; return;
} }
// 获取当前的用户 // 获取当前的用户
LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest()); LoginUser loginUser = SpringUtils.getBean(TokenService.class).getLoginUser(ServletUtils.getRequest());
// *========数据库日志=========*// // *========数据库日志=========*//
SysOperLog operLog = new SysOperLog(); SysOperLog operLog = new SysOperLog();
operLog.setStatus(BusinessStatus.SUCCESS.ordinal()); operLog.setStatus(BusinessStatus.SUCCESS.ordinal());
// 请求的地址 // 请求的地址
String ip = IpUtils.getIpAddr(ServletUtils.getRequest()); String ip = IpUtils.getIpAddr(ServletUtils.getRequest());
operLog.setOperIp(ip); operLog.setOperIp(ip);
// 返回参数 // 返回参数
operLog.setJsonResult(JSON.toJSONString(jsonResult)); operLog.setJsonResult(JSON.toJSONString(jsonResult));
operLog.setOperUrl(ServletUtils.getRequest().getRequestURI()); operLog.setOperUrl(ServletUtils.getRequest().getRequestURI());
if (loginUser != null) if (loginUser != null)
{ {
operLog.setOperName(loginUser.getUsername()); operLog.setOperName(loginUser.getUsername());
} }
if (e != null) if (e != null)
{ {
operLog.setStatus(BusinessStatus.FAIL.ordinal()); operLog.setStatus(BusinessStatus.FAIL.ordinal());
operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000)); operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
} }
// 设置方法名称 // 设置方法名称
String className = joinPoint.getTarget().getClass().getName(); String className = joinPoint.getTarget().getClass().getName();
String methodName = joinPoint.getSignature().getName(); String methodName = joinPoint.getSignature().getName();
operLog.setMethod(className + "." + methodName + "()"); operLog.setMethod(className + "." + methodName + "()");
// 设置请求方式 // 设置请求方式
operLog.setRequestMethod(ServletUtils.getRequest().getMethod()); operLog.setRequestMethod(ServletUtils.getRequest().getMethod());
// 处理设置注解上的参数 // 处理设置注解上的参数
getControllerMethodDescription(joinPoint, controllerLog, operLog); getControllerMethodDescription(joinPoint, controllerLog, operLog);
// 保存数据库 // 保存数据库
AsyncManager.me().execute(AsyncFactory.recordOper(operLog)); AsyncManager.me().execute(AsyncFactory.recordOper(operLog));
} }
catch (Exception exp) catch (Exception exp)
{ {
// 记录本地异常日志 // 记录本地异常日志
log.error("==前置通知异常=="); log.error("==前置通知异常==");
log.error("异常信息:{}", exp.getMessage()); log.error("异常信息:{}", exp.getMessage());
exp.printStackTrace(); exp.printStackTrace();
} }
} }
/** /**
* 获取注解中对方法的描述信息 用于Controller层注解 * 获取注解中对方法的描述信息 用于Controller层注解
* *
* @param log 日志 * @param log 日志
* @param operLog 操作日志 * @param operLog 操作日志
* @throws Exception * @throws Exception
*/ */
public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) throws Exception public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) throws Exception
{ {
// 设置action动作 // 设置action动作
operLog.setBusinessType(log.businessType().ordinal()); operLog.setBusinessType(log.businessType().ordinal());
// 设置标题 // 设置标题
operLog.setTitle(log.title()); operLog.setTitle(log.title());
// 设置操作人类别 // 设置操作人类别
operLog.setOperatorType(log.operatorType().ordinal()); operLog.setOperatorType(log.operatorType().ordinal());
// 是否需要保存request，参数和值 // 是否需要保存request，参数和值
if (log.isSaveRequestData()) if (log.isSaveRequestData())
{ {
// 获取参数的信息，传入到数据库中。 // 获取参数的信息，传入到数据库中。
setRequestValue(joinPoint, operLog); setRequestValue(joinPoint, operLog);
} }
} }
/** /**
* 获取请求的参数，放到log中 * 获取请求的参数，放到log中
* *
* @param operLog 操作日志 * @param operLog 操作日志
* @throws Exception 异常 * @throws Exception 异常
*/ */
private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception private void setRequestValue(JoinPoint joinPoint, SysOperLog operLog) throws Exception
{ {
String requestMethod = operLog.getRequestMethod(); String requestMethod = operLog.getRequestMethod();
if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod)) if (HttpMethod.PUT.name().equals(requestMethod) || HttpMethod.POST.name().equals(requestMethod))
{ {
String params = argsArrayToString(joinPoint.getArgs()); String params = argsArrayToString(joinPoint.getArgs());
operLog.setOperParam(StringUtils.substring(params, 0, 2000)); operLog.setOperParam(StringUtils.substring(params, 0, 2000));
} }
else else
{ {
Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE); Map<?, ?> paramsMap = (Map<?, ?>) ServletUtils.getRequest().getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE);
operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000)); operLog.setOperParam(StringUtils.substring(paramsMap.toString(), 0, 2000));
} }
} }
/** /**
* 是否存在注解，如果存在就获取 * 是否存在注解，如果存在就获取
*/ */
private Log getAnnotationLog(JoinPoint joinPoint) throws Exception private Log getAnnotationLog(JoinPoint joinPoint) throws Exception
{ {
Signature signature = joinPoint.getSignature(); Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature; MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod(); Method method = methodSignature.getMethod();
if (method != null) if (method != null)
{ {
return method.getAnnotation(Log.class); return method.getAnnotation(Log.class);
} }
return null; return null;
} }
/** /**
* 参数拼装 * 参数拼装
*/ */
private String argsArrayToString(Object[] paramsArray) private String argsArrayToString(Object[] paramsArray)
{ {
String params = ""; String params = "";
if (paramsArray != null && paramsArray.length > 0) if (paramsArray != null && paramsArray.length > 0)
{ {
for (int i = 0; i < paramsArray.length; i++) for (int i = 0; i < paramsArray.length; i++)
{ {
if (!isFilterObject(paramsArray[i])) if (!isFilterObject(paramsArray[i]))
{ {
Object jsonObj = JSON.toJSON(paramsArray[i]); Object jsonObj = JSON.toJSON(paramsArray[i]);
params += jsonObj.toString() + " "; params += jsonObj.toString() + " ";
} }
} }
} }
return params.trim(); return params.trim();
} }
/** /**
* 判断是否需要过滤的对象。 * 判断是否需要过滤的对象。
* *
* @param o 对象信息。 * @param o 对象信息。
* @return 如果是需要过滤的对象，则返回true；否则返回false。 * @return 如果是需要过滤的对象，则返回true；否则返回false。
*/ */
public boolean isFilterObject(final Object o) public boolean isFilterObject(final Object o)
{ {
return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse; return o instanceof MultipartFile || o instanceof HttpServletRequest || o instanceof HttpServletResponse;
} }
} }

56
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/annotation/DataScope.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/annotation/DataScope.java
View File

@ -1,28 +1,28 @@
package com.ruoyi.framework.aspectj.lang.annotation; package com.uvaluation.framework.aspectj.lang.annotation;
import java.lang.annotation.Documented; import java.lang.annotation.Documented;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; import java.lang.annotation.Target;
/** /**
* 数据权限过滤注解 * 数据权限过滤注解
* *
* @author ruoyi * @author ruoyi
*/ */
@Target(ElementType.METHOD) @Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Documented @Documented
public @interface DataScope public @interface DataScope
{ {
/** /**
* 部门表的别名 * 部门表的别名
*/ */
public String deptAlias() default ""; public String deptAlias() default "";
/** /**
* 用户表的别名 * 用户表的别名
*/ */
public String userAlias() default ""; public String userAlias() default "";
} }

56
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/annotation/DataSource.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/annotation/DataSource.java
View File

@ -1,28 +1,28 @@
package com.ruoyi.framework.aspectj.lang.annotation; package com.uvaluation.framework.aspectj.lang.annotation;
import java.lang.annotation.Documented; import java.lang.annotation.Documented;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited; import java.lang.annotation.Inherited;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; import java.lang.annotation.Target;
import com.ruoyi.framework.aspectj.lang.enums.DataSourceType; import com.uvaluation.framework.aspectj.lang.enums.DataSourceType;
/** /**
* 自定义多数据源切换注解 * 自定义多数据源切换注解
* *
* 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
* *
* @author ruoyi * @author ruoyi
*/ */
@Target({ ElementType.METHOD, ElementType.TYPE }) @Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Documented @Documented
@Inherited @Inherited
public @interface DataSource public @interface DataSource
{ {
/** /**
* 切换数据源名称 * 切换数据源名称
*/ */
public DataSourceType value() default DataSourceType.MASTER; public DataSourceType value() default DataSourceType.MASTER;
} }

2
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/annotation/Excel.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/annotation/Excel.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.framework.aspectj.lang.annotation; package com.uvaluation.framework.aspectj.lang.annotation;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;

2
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/annotation/Excels.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/annotation/Excels.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.framework.aspectj.lang.annotation; package com.uvaluation.framework.aspectj.lang.annotation;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;

82
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/annotation/Log.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/annotation/Log.java
View File

@ -1,41 +1,41 @@
package com.ruoyi.framework.aspectj.lang.annotation; package com.uvaluation.framework.aspectj.lang.annotation;
import java.lang.annotation.Documented; import java.lang.annotation.Documented;
import java.lang.annotation.ElementType; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; import java.lang.annotation.Target;
import com.ruoyi.framework.aspectj.lang.enums.BusinessType; import com.uvaluation.framework.aspectj.lang.enums.BusinessType;
import com.ruoyi.framework.aspectj.lang.enums.OperatorType; import com.uvaluation.framework.aspectj.lang.enums.OperatorType;
/** /**
* 自定义操作日志记录注解 * 自定义操作日志记录注解
* *
* @author ruoyi * @author ruoyi
* *
*/ */
@Target({ ElementType.PARAMETER, ElementType.METHOD }) @Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME) @Retention(RetentionPolicy.RUNTIME)
@Documented @Documented
public @interface Log public @interface Log
{ {
/** /**
* 模块 * 模块
*/ */
public String title() default ""; public String title() default "";
/** /**
* 功能 * 功能
*/ */
public BusinessType businessType() default BusinessType.OTHER; public BusinessType businessType() default BusinessType.OTHER;
/** /**
* 操作人类别 * 操作人类别
*/ */
public OperatorType operatorType() default OperatorType.MANAGE; public OperatorType operatorType() default OperatorType.MANAGE;
/** /**
* 是否保存请求的参数 * 是否保存请求的参数
*/ */
public boolean isSaveRequestData() default true; public boolean isSaveRequestData() default true;
} }

40
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/enums/BusinessStatus.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/enums/BusinessStatus.java
View File

@ -1,20 +1,20 @@
package com.ruoyi.framework.aspectj.lang.enums; package com.uvaluation.framework.aspectj.lang.enums;
/** /**
* 操作状态 * 操作状态
* *
* @author ruoyi * @author ruoyi
* *
*/ */
public enum BusinessStatus public enum BusinessStatus
{ {
/** /**
* 成功 * 成功
*/ */
SUCCESS, SUCCESS,
/** /**
* 失败 * 失败
*/ */
FAIL, FAIL,
} }

118
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/enums/BusinessType.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/enums/BusinessType.java
View File

@ -1,59 +1,59 @@
package com.ruoyi.framework.aspectj.lang.enums; package com.uvaluation.framework.aspectj.lang.enums;
/** /**
* 业务操作类型 * 业务操作类型
* *
* @author ruoyi * @author ruoyi
*/ */
public enum BusinessType public enum BusinessType
{ {
/** /**
* 其它 * 其它
*/ */
OTHER, OTHER,
/** /**
* 新增 * 新增
*/ */
INSERT, INSERT,
/** /**
* 修改 * 修改
*/ */
UPDATE, UPDATE,
/** /**
* 删除 * 删除
*/ */
DELETE, DELETE,
/** /**
* 授权 * 授权
*/ */
GRANT, GRANT,
/** /**
* 导出 * 导出
*/ */
EXPORT, EXPORT,
/** /**
* 导入 * 导入
*/ */
IMPORT, IMPORT,
/** /**
* 强退 * 强退
*/ */
FORCE, FORCE,
/** /**
* 生成代码 * 生成代码
*/ */
GENCODE, GENCODE,
/** /**
* 清空数据 * 清空数据
*/ */
CLEAN, CLEAN,
} }

38
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/enums/DataSourceType.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/enums/DataSourceType.java
View File

@ -1,19 +1,19 @@
package com.ruoyi.framework.aspectj.lang.enums; package com.uvaluation.framework.aspectj.lang.enums;
/** /**
* 数据源 * 数据源
* *
* @author ruoyi * @author ruoyi
*/ */
public enum DataSourceType public enum DataSourceType
{ {
/** /**
* 主库 * 主库
*/ */
MASTER, MASTER,
/** /**
* 从库 * 从库
*/ */
SLAVE SLAVE
} }

48
ruoyi/src/main/java/com/ruoyi/framework/aspectj/lang/enums/OperatorType.java → ruoyi/src/main/java/com/uvaluation/framework/aspectj/lang/enums/OperatorType.java
View File

@ -1,24 +1,24 @@
package com.ruoyi.framework.aspectj.lang.enums; package com.uvaluation.framework.aspectj.lang.enums;
/** /**
* 操作人类别 * 操作人类别
* *
* @author ruoyi * @author ruoyi
*/ */
public enum OperatorType public enum OperatorType
{ {
/** /**
* 其它 * 其它
*/ */
OTHER, OTHER,
/** /**
* 后台用户 * 后台用户
*/ */
MANAGE, MANAGE,
/** /**
* 手机端用户 * 手机端用户
*/ */
MOBILE MOBILE
} }

60
ruoyi/src/main/java/com/ruoyi/framework/config/ApplicationConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/ApplicationConfig.java
View File

@ -1,30 +1,30 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.util.TimeZone; import java.util.TimeZone;
import org.mybatis.spring.annotation.MapperScan; import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer; import org.springframework.boot.autoconfigure.jackson.Jackson2ObjectMapperBuilderCustomizer;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy; import org.springframework.context.annotation.EnableAspectJAutoProxy;
/** /**
* 程序注解配置 * 程序注解配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
// 表示通过aop框架暴露该代理对象,AopContext能够访问 // 表示通过aop框架暴露该代理对象,AopContext能够访问
@EnableAspectJAutoProxy(exposeProxy = true) @EnableAspectJAutoProxy(exposeProxy = true)
// 指定要扫描的Mapper类的包的路径 // 指定要扫描的Mapper类的包的路径
@MapperScan("com.ruoyi.project.**.mapper") @MapperScan("com.ruoyi.project.**.mapper")
public class ApplicationConfig public class ApplicationConfig
{ {
/** /**
* 时区配置 * 时区配置
*/ */
@Bean @Bean
public Jackson2ObjectMapperBuilderCustomizer jacksonObjectMapperCustomization() public Jackson2ObjectMapperBuilderCustomizer jacksonObjectMapperCustomization()
{ {
return jacksonObjectMapperBuilder -> jacksonObjectMapperBuilder.timeZone(TimeZone.getDefault()); return jacksonObjectMapperBuilder -> jacksonObjectMapperBuilder.timeZone(TimeZone.getDefault());
} }
} }

0
ruoyi/src/main/java/com/ruoyi/framework/config/DruidConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/DruidConfig.java
View File

138
ruoyi/src/main/java/com/ruoyi/framework/config/FastJson2JsonRedisSerializer.java → ruoyi/src/main/java/com/uvaluation/framework/config/FastJson2JsonRedisSerializer.java
View File

@ -1,69 +1,69 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature; import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory; import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer; import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException; import org.springframework.data.redis.serializer.SerializationException;
import com.alibaba.fastjson.parser.ParserConfig; import com.alibaba.fastjson.parser.ParserConfig;
import org.springframework.util.Assert; import org.springframework.util.Assert;
import java.nio.charset.Charset; import java.nio.charset.Charset;
/** /**
* Redis使用FastJson序列化 * Redis使用FastJson序列化
* *
* @author ruoyi * @author ruoyi
*/ */
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T> public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{ {
@SuppressWarnings("unused") @SuppressWarnings("unused")
private ObjectMapper objectMapper = new ObjectMapper(); private ObjectMapper objectMapper = new ObjectMapper();
public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8"); public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private Class<T> clazz; private Class<T> clazz;
static static
{ {
ParserConfig.getGlobalInstance().setAutoTypeSupport(true); ParserConfig.getGlobalInstance().setAutoTypeSupport(true);
} }
public FastJson2JsonRedisSerializer(Class<T> clazz) public FastJson2JsonRedisSerializer(Class<T> clazz)
{ {
super(); super();
this.clazz = clazz; this.clazz = clazz;
} }
public byte[] serialize(T t) throws SerializationException public byte[] serialize(T t) throws SerializationException
{ {
if (t == null) if (t == null)
{ {
return new byte[0]; return new byte[0];
} }
return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET); return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);
} }
public T deserialize(byte[] bytes) throws SerializationException public T deserialize(byte[] bytes) throws SerializationException
{ {
if (bytes == null || bytes.length <= 0) if (bytes == null || bytes.length <= 0)
{ {
return null; return null;
} }
String str = new String(bytes, DEFAULT_CHARSET); String str = new String(bytes, DEFAULT_CHARSET);
return JSON.parseObject(str, clazz); return JSON.parseObject(str, clazz);
} }
public void setObjectMapper(ObjectMapper objectMapper) public void setObjectMapper(ObjectMapper objectMapper)
{ {
Assert.notNull(objectMapper, "'objectMapper' must not be null"); Assert.notNull(objectMapper, "'objectMapper' must not be null");
this.objectMapper = objectMapper; this.objectMapper = objectMapper;
} }
protected JavaType getJavaType(Class<?> clazz) protected JavaType getJavaType(Class<?> clazz)
{ {
return TypeFactory.defaultInstance().constructType(clazz); return TypeFactory.defaultInstance().constructType(clazz);
} }
} }

120
ruoyi/src/main/java/com/ruoyi/framework/config/FilterConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/FilterConfig.java
View File

@ -1,60 +1,60 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.util.HashMap; import java.util.HashMap;
import java.util.Map; import java.util.Map;
import javax.servlet.DispatcherType; import javax.servlet.DispatcherType;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import com.ruoyi.common.filter.RepeatableFilter; import com.uvaluation.common.filter.RepeatableFilter;
import com.ruoyi.common.filter.XssFilter; import com.uvaluation.common.filter.XssFilter;
import com.ruoyi.common.utils.StringUtils; import com.uvaluation.common.utils.StringUtils;
/** /**
* Filter配置 * Filter配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
public class FilterConfig public class FilterConfig
{ {
@Value("${xss.enabled}") @Value("${xss.enabled}")
private String enabled; private String enabled;
@Value("${xss.excludes}") @Value("${xss.excludes}")
private String excludes; private String excludes;
@Value("${xss.urlPatterns}") @Value("${xss.urlPatterns}")
private String urlPatterns; private String urlPatterns;
@SuppressWarnings({ "rawtypes", "unchecked" }) @SuppressWarnings({ "rawtypes", "unchecked" })
@Bean @Bean
public FilterRegistrationBean xssFilterRegistration() public FilterRegistrationBean xssFilterRegistration()
{ {
FilterRegistrationBean registration = new FilterRegistrationBean(); FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setDispatcherTypes(DispatcherType.REQUEST); registration.setDispatcherTypes(DispatcherType.REQUEST);
registration.setFilter(new XssFilter()); registration.setFilter(new XssFilter());
registration.addUrlPatterns(StringUtils.split(urlPatterns, ",")); registration.addUrlPatterns(StringUtils.split(urlPatterns, ","));
registration.setName("xssFilter"); registration.setName("xssFilter");
registration.setOrder(FilterRegistrationBean.HIGHEST_PRECEDENCE); registration.setOrder(FilterRegistrationBean.HIGHEST_PRECEDENCE);
Map<String, String> initParameters = new HashMap<String, String>(); Map<String, String> initParameters = new HashMap<String, String>();
initParameters.put("excludes", excludes); initParameters.put("excludes", excludes);
initParameters.put("enabled", enabled); initParameters.put("enabled", enabled);
registration.setInitParameters(initParameters); registration.setInitParameters(initParameters);
return registration; return registration;
} }
@SuppressWarnings({ "rawtypes", "unchecked" }) @SuppressWarnings({ "rawtypes", "unchecked" })
@Bean @Bean
public FilterRegistrationBean someFilterRegistration() public FilterRegistrationBean someFilterRegistration()
{ {
FilterRegistrationBean registration = new FilterRegistrationBean(); FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new RepeatableFilter()); registration.setFilter(new RepeatableFilter());
registration.addUrlPatterns("/*"); registration.addUrlPatterns("/*");
registration.setName("repeatableFilter"); registration.setName("repeatableFilter");
registration.setOrder(FilterRegistrationBean.LOWEST_PRECEDENCE); registration.setOrder(FilterRegistrationBean.LOWEST_PRECEDENCE);
return registration; return registration;
} }
} }

132
ruoyi/src/main/java/com/ruoyi/framework/config/GenConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/GenConfig.java
View File

@ -1,66 +1,66 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
/** /**
* 读取代码生成相关配置 * 读取代码生成相关配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Component @Component
@ConfigurationProperties(prefix = "gen") @ConfigurationProperties(prefix = "gen")
public class GenConfig public class GenConfig
{ {
/** 作者 */ /** 作者 */
public static String author; public static String author;
/** 生成包路径 */ /** 生成包路径 */
public static String packageName; public static String packageName;
/** 自动去除表前缀，默认是true */ /** 自动去除表前缀，默认是true */
public static boolean autoRemovePre; public static boolean autoRemovePre;
/** 表前缀(类名不会包含表前缀) */ /** 表前缀(类名不会包含表前缀) */
public static String tablePrefix; public static String tablePrefix;
public static String getAuthor() public static String getAuthor()
{ {
return author; return author;
} }
public void setAuthor(String author) public void setAuthor(String author)
{ {
GenConfig.author = author; GenConfig.author = author;
} }
public static String getPackageName() public static String getPackageName()
{ {
return packageName; return packageName;
} }
public void setPackageName(String packageName) public void setPackageName(String packageName)
{ {
GenConfig.packageName = packageName; GenConfig.packageName = packageName;
} }
public static boolean getAutoRemovePre() public static boolean getAutoRemovePre()
{ {
return autoRemovePre; return autoRemovePre;
} }
public void setAutoRemovePre(boolean autoRemovePre) public void setAutoRemovePre(boolean autoRemovePre)
{ {
GenConfig.autoRemovePre = autoRemovePre; GenConfig.autoRemovePre = autoRemovePre;
} }
public static String getTablePrefix() public static String getTablePrefix()
{ {
return tablePrefix; return tablePrefix;
} }
public void setTablePrefix(String tablePrefix) public void setTablePrefix(String tablePrefix)
{ {
GenConfig.tablePrefix = tablePrefix; GenConfig.tablePrefix = tablePrefix;
} }
} }

23
ruoyi/src/main/java/com/ruoyi/framework/config/HikariCPConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/HikariCPConfig.java
View File

@ -1,31 +1,12 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.sql.DataSource;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
//import com.alibaba.druid.pool.DruidDataSource; //import com.alibaba.druid.pool.DruidDataSource;
//import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder; //import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
//import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties; //import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
//import com.alibaba.druid.util.Utils; //import com.alibaba.druid.util.Utils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.framework.aspectj.lang.enums.DataSourceType;
import com.ruoyi.framework.datasource.DynamicDataSource;
/** /**
* druid 配置多数据源 * druid 配置多数据源

214
ruoyi/src/main/java/com/ruoyi/framework/config/MyBatisConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/MyBatisConfig.java
View File

@ -1,108 +1,108 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashSet; import java.util.HashSet;
import java.util.List; import java.util.List;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.apache.ibatis.io.VFS; import org.apache.ibatis.io.VFS;
import org.apache.ibatis.session.SqlSessionFactory; import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.boot.autoconfigure.SpringBootVFS; import org.mybatis.spring.boot.autoconfigure.SpringBootVFS;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.Environment; import org.springframework.core.env.Environment;
import org.springframework.core.io.DefaultResourceLoader; import org.springframework.core.io.DefaultResourceLoader;
import org.springframework.core.io.Resource; import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver; import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory; import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader; import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory; import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.ClassUtils; import org.springframework.util.ClassUtils;
/** /**
* Mybatis支持*匹配扫描包 * Mybatis支持*匹配扫描包
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
public class MyBatisConfig public class MyBatisConfig
{ {
@Autowired @Autowired
private Environment env; private Environment env;
static final String DEFAULT_RESOURCE_PATTERN = "**/*.class"; static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
public static String setTypeAliasesPackage(String typeAliasesPackage) public static String setTypeAliasesPackage(String typeAliasesPackage)
{ {
ResourcePatternResolver resolver = (ResourcePatternResolver) new PathMatchingResourcePatternResolver(); ResourcePatternResolver resolver = (ResourcePatternResolver) new PathMatchingResourcePatternResolver();
MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver); MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resolver);
List<String> allResult = new ArrayList<String>(); List<String> allResult = new ArrayList<String>();
try try
{ {
for (String aliasesPackage : typeAliasesPackage.split(",")) for (String aliasesPackage : typeAliasesPackage.split(","))
{ {
List<String> result = new ArrayList<String>(); List<String> result = new ArrayList<String>();
aliasesPackage = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX aliasesPackage = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
+ ClassUtils.convertClassNameToResourcePath(aliasesPackage.trim()) + "/" + DEFAULT_RESOURCE_PATTERN; + ClassUtils.convertClassNameToResourcePath(aliasesPackage.trim()) + "/" + DEFAULT_RESOURCE_PATTERN;
Resource[] resources = resolver.getResources(aliasesPackage); Resource[] resources = resolver.getResources(aliasesPackage);
if (resources != null && resources.length > 0) if (resources != null && resources.length > 0)
{ {
MetadataReader metadataReader = null; MetadataReader metadataReader = null;
for (Resource resource : resources) for (Resource resource : resources)
{ {
if (resource.isReadable()) if (resource.isReadable())
{ {
metadataReader = metadataReaderFactory.getMetadataReader(resource); metadataReader = metadataReaderFactory.getMetadataReader(resource);
try try
{ {
result.add(Class.forName(metadataReader.getClassMetadata().getClassName()).getPackage().getName()); result.add(Class.forName(metadataReader.getClassMetadata().getClassName()).getPackage().getName());
} }
catch (ClassNotFoundException e) catch (ClassNotFoundException e)
{ {
e.printStackTrace(); e.printStackTrace();
} }
} }
} }
} }
if (result.size() > 0) if (result.size() > 0)
{ {
HashSet<String> hashResult = new HashSet<String>(result); HashSet<String> hashResult = new HashSet<String>(result);
allResult.addAll(hashResult); allResult.addAll(hashResult);
} }
} }
if (allResult.size() > 0) if (allResult.size() > 0)
{ {
typeAliasesPackage = String.join(",", (String[]) allResult.toArray(new String[0])); typeAliasesPackage = String.join(",", (String[]) allResult.toArray(new String[0]));
} }
else else
{ {
throw new RuntimeException("mybatis typeAliasesPackage 路径扫描错误,参数typeAliasesPackage:" + typeAliasesPackage + "未找到任何包"); throw new RuntimeException("mybatis typeAliasesPackage 路径扫描错误,参数typeAliasesPackage:" + typeAliasesPackage + "未找到任何包");
} }
} }
catch (IOException e) catch (IOException e)
{ {
e.printStackTrace(); e.printStackTrace();
} }
return typeAliasesPackage; return typeAliasesPackage;
} }
@Bean @Bean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception
{ {
String typeAliasesPackage = env.getProperty("mybatis.typeAliasesPackage"); String typeAliasesPackage = env.getProperty("mybatis.typeAliasesPackage");
String mapperLocations = env.getProperty("mybatis.mapperLocations"); String mapperLocations = env.getProperty("mybatis.mapperLocations");
String configLocation = env.getProperty("mybatis.configLocation"); String configLocation = env.getProperty("mybatis.configLocation");
typeAliasesPackage = setTypeAliasesPackage(typeAliasesPackage); typeAliasesPackage = setTypeAliasesPackage(typeAliasesPackage);
VFS.addImplClass(SpringBootVFS.class); VFS.addImplClass(SpringBootVFS.class);
final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean(); final SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(dataSource); sessionFactory.setDataSource(dataSource);
sessionFactory.setTypeAliasesPackage(typeAliasesPackage); sessionFactory.setTypeAliasesPackage(typeAliasesPackage);
sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations)); sessionFactory.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
sessionFactory.setConfigLocation(new DefaultResourceLoader().getResource(configLocation)); sessionFactory.setConfigLocation(new DefaultResourceLoader().getResource(configLocation));
return sessionFactory.getObject(); return sessionFactory.getObject();
} }
} }

86
ruoyi/src/main/java/com/ruoyi/framework/config/RedisConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/RedisConfig.java
View File

@ -1,43 +1,43 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.cache.annotation.CachingConfigurerSupport; import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching; import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer;
import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
/** /**
* redis配置 * redis配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
@EnableCaching @EnableCaching
public class RedisConfig extends CachingConfigurerSupport public class RedisConfig extends CachingConfigurerSupport
{ {
@Bean @Bean
@SuppressWarnings(value = { "unchecked", "rawtypes" }) @SuppressWarnings(value = { "unchecked", "rawtypes" })
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory)
{ {
RedisTemplate<Object, Object> template = new RedisTemplate<>(); RedisTemplate<Object, Object> template = new RedisTemplate<>();
template.setConnectionFactory(connectionFactory); template.setConnectionFactory(connectionFactory);
FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class); FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);
ObjectMapper mapper = new ObjectMapper(); ObjectMapper mapper = new ObjectMapper();
mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(mapper); serializer.setObjectMapper(mapper);
template.setValueSerializer(serializer); template.setValueSerializer(serializer);
// 使用StringRedisSerializer来序列化和反序列化redis的key值 // 使用StringRedisSerializer来序列化和反序列化redis的key值
template.setKeySerializer(new StringRedisSerializer()); template.setKeySerializer(new StringRedisSerializer());
template.afterPropertiesSet(); template.afterPropertiesSet();
return template; return template;
} }
} }

80
ruoyi/src/main/java/com/ruoyi/framework/config/ResourcesConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/ResourcesConfig.java
View File

@ -1,41 +1,41 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry; import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import com.ruoyi.common.constant.Constants; import com.uvaluation.common.constant.Constants;
import com.ruoyi.framework.interceptor.RepeatSubmitInterceptor; import com.uvaluation.framework.interceptor.RepeatSubmitInterceptor;
/** /**
* 通用配置 * 通用配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
public class ResourcesConfig implements WebMvcConfigurer public class ResourcesConfig implements WebMvcConfigurer
{ {
@Autowired @Autowired
private RepeatSubmitInterceptor repeatSubmitInterceptor; private RepeatSubmitInterceptor repeatSubmitInterceptor;
@Override @Override
public void addResourceHandlers(ResourceHandlerRegistry registry) public void addResourceHandlers(ResourceHandlerRegistry registry)
{ {
/** 本地文件上传路径 */ /** 本地文件上传路径 */
registry.addResourceHandler(Constants.RESOURCE_PREFIX + "/**").addResourceLocations("file:" + RuoYiConfig.getProfile() + "/"); registry.addResourceHandler(Constants.RESOURCE_PREFIX + "/**").addResourceLocations("file:" + RuoYiConfig.getProfile() + "/");
/** swagger配置 */ /** swagger配置 */
registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/"); registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/"); registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
} }
/** /**
* 自定义拦截规则 * 自定义拦截规则
*/ */
@Override @Override
public void addInterceptors(InterceptorRegistry registry) public void addInterceptors(InterceptorRegistry registry)
{ {
registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**"); registry.addInterceptor(repeatSubmitInterceptor).addPathPatterns("/**");
} }
} }

230
ruoyi/src/main/java/com/ruoyi/framework/config/RuoYiConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/RuoYiConfig.java
View File

@ -1,116 +1,116 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
/** /**
* 读取项目相关配置 * 读取项目相关配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Component @Component
@ConfigurationProperties(prefix = "ruoyi") @ConfigurationProperties(prefix = "ruoyi")
public class RuoYiConfig public class RuoYiConfig
{ {
/** 项目名称 */ /** 项目名称 */
private String name; private String name;
/** 版本 */ /** 版本 */
private String version; private String version;
/** 版权年份 */ /** 版权年份 */
private String copyrightYear; private String copyrightYear;
/** 实例演示开关 */ /** 实例演示开关 */
private boolean demoEnabled; private boolean demoEnabled;
/** 上传路径 */ /** 上传路径 */
private static String profile; private static String profile;
/** 获取地址开关 */ /** 获取地址开关 */
private static boolean addressEnabled; private static boolean addressEnabled;
public String getName() public String getName()
{ {
return name; return name;
} }
public void setName(String name) public void setName(String name)
{ {
this.name = name; this.name = name;
} }
public String getVersion() public String getVersion()
{ {
return version; return version;
} }
public void setVersion(String version) public void setVersion(String version)
{ {
this.version = version; this.version = version;
} }
public String getCopyrightYear() public String getCopyrightYear()
{ {
return copyrightYear; return copyrightYear;
} }
public void setCopyrightYear(String copyrightYear) public void setCopyrightYear(String copyrightYear)
{ {
this.copyrightYear = copyrightYear; this.copyrightYear = copyrightYear;
} }
public boolean isDemoEnabled() public boolean isDemoEnabled()
{ {
return demoEnabled; return demoEnabled;
} }
public void setDemoEnabled(boolean demoEnabled) public void setDemoEnabled(boolean demoEnabled)
{ {
this.demoEnabled = demoEnabled; this.demoEnabled = demoEnabled;
} }
public static String getProfile() public static String getProfile()
{ {
return profile; return profile;
} }
public void setProfile(String profile) public void setProfile(String profile)
{ {
RuoYiConfig.profile = profile; RuoYiConfig.profile = profile;
} }
public static boolean isAddressEnabled() public static boolean isAddressEnabled()
{ {
return addressEnabled; return addressEnabled;
} }
public void setAddressEnabled(boolean addressEnabled) public void setAddressEnabled(boolean addressEnabled)
{ {
RuoYiConfig.addressEnabled = addressEnabled; RuoYiConfig.addressEnabled = addressEnabled;
} }
/** /**
* 获取头像上传路径 * 获取头像上传路径
*/ */
public static String getAvatarPath() public static String getAvatarPath()
{ {
return getProfile() + "/avatar"; return getProfile() + "/avatar";
} }
/** /**
* 获取下载路径 * 获取下载路径
*/ */
public static String getDownloadPath() public static String getDownloadPath()
{ {
return getProfile() + "/download/"; return getProfile() + "/download/";
} }
/** /**
* 获取上传路径 * 获取上传路径
*/ */
public static String getUploadPath() public static String getUploadPath()
{ {
return getProfile() + "/upload"; return getProfile() + "/upload";
} }
} }

2
ruoyi/src/main/java/com/ruoyi/framework/config/ScheduleConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/ScheduleConfig.java
View File

@ -1,4 +1,4 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;

270
ruoyi/src/main/java/com/ruoyi/framework/config/SecurityConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/SecurityConfig.java
View File

@ -1,135 +1,135 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpMethod; import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity; 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.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy; import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
import com.ruoyi.framework.security.filter.JwtAuthenticationTokenFilter; import com.uvaluation.framework.security.filter.JwtAuthenticationTokenFilter;
import com.ruoyi.framework.security.handle.AuthenticationEntryPointImpl; import com.uvaluation.framework.security.handle.AuthenticationEntryPointImpl;
import com.ruoyi.framework.security.handle.LogoutSuccessHandlerImpl; import com.uvaluation.framework.security.handle.LogoutSuccessHandlerImpl;
/** /**
* spring security配置 * spring security配置
* *
* @author ruoyi * @author ruoyi
*/ */
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true) @EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfig extends WebSecurityConfigurerAdapter public class SecurityConfig extends WebSecurityConfigurerAdapter
{ {
/** /**
* 自定义用户认证逻辑 * 自定义用户认证逻辑
*/ */
@Autowired @Autowired
private UserDetailsService userDetailsService; private UserDetailsService userDetailsService;
/** /**
* 认证失败处理类 * 认证失败处理类
*/ */
@Autowired @Autowired
private AuthenticationEntryPointImpl unauthorizedHandler; private AuthenticationEntryPointImpl unauthorizedHandler;
/** /**
* 退出处理类 * 退出处理类
*/ */
@Autowired @Autowired
private LogoutSuccessHandlerImpl logoutSuccessHandler; private LogoutSuccessHandlerImpl logoutSuccessHandler;
/** /**
* token认证过滤器 * token认证过滤器
*/ */
@Autowired @Autowired
private JwtAuthenticationTokenFilter authenticationTokenFilter; private JwtAuthenticationTokenFilter authenticationTokenFilter;
/** /**
* 解决 无法直接注入 AuthenticationManager * 解决 无法直接注入 AuthenticationManager
* *
* @return * @return
* @throws Exception * @throws Exception
*/ */
@Bean @Bean
@Override @Override
public AuthenticationManager authenticationManagerBean() throws Exception public AuthenticationManager authenticationManagerBean() throws Exception
{ {
return super.authenticationManagerBean(); return super.authenticationManagerBean();
} }
/** /**
* anyRequest | 匹配所有请求路径 * anyRequest | 匹配所有请求路径
* access | SpringEl表达式结果为true时可以访问 * access | SpringEl表达式结果为true时可以访问
* anonymous | 匿名可以访问 * anonymous | 匿名可以访问
* denyAll | 用户不能访问 * denyAll | 用户不能访问
* fullyAuthenticated | 用户完全认证可以访问（非remember-me下自动登录） * fullyAuthenticated | 用户完全认证可以访问（非remember-me下自动登录）
* hasAnyAuthority | 如果有参数，参数表示权限，则其中任何一个权限可以访问 * hasAnyAuthority | 如果有参数，参数表示权限，则其中任何一个权限可以访问
* hasAnyRole | 如果有参数，参数表示角色，则其中任何一个角色可以访问 * hasAnyRole | 如果有参数，参数表示角色，则其中任何一个角色可以访问
* hasAuthority | 如果有参数，参数表示权限，则其权限可以访问 * hasAuthority | 如果有参数，参数表示权限，则其权限可以访问
* hasIpAddress | 如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问 * hasIpAddress | 如果有参数，参数表示IP地址，如果用户IP和参数匹配，则可以访问
* hasRole | 如果有参数，参数表示角色，则其角色可以访问 * hasRole | 如果有参数，参数表示角色，则其角色可以访问
* permitAll | 用户可以任意访问 * permitAll | 用户可以任意访问
* rememberMe | 允许通过remember-me登录的用户访问 * rememberMe | 允许通过remember-me登录的用户访问
* authenticated | 用户登录后可访问 * authenticated | 用户登录后可访问
*/ */
@Override @Override
protected void configure(HttpSecurity httpSecurity) throws Exception protected void configure(HttpSecurity httpSecurity) throws Exception
{ {
httpSecurity httpSecurity
// CRSF禁用，因为不使用session // CRSF禁用，因为不使用session
.csrf().disable() .csrf().disable()
// 认证失败处理类 // 认证失败处理类
.exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and() .exceptionHandling().authenticationEntryPoint(unauthorizedHandler).and()
// 基于token，所以不需要session // 基于token，所以不需要session
.sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and() .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
// 过滤请求 // 过滤请求
.authorizeRequests() .authorizeRequests()
// 对于登录login 验证码captchaImage 允许匿名访问 // 对于登录login 验证码captchaImage 允许匿名访问
.antMatchers("/login", "/captchaImage").anonymous() .antMatchers("/login", "/captchaImage").anonymous()
.antMatchers( .antMatchers(
HttpMethod.GET, HttpMethod.GET,
"/*.html", "/*.html",
"/**/*.html", "/**/*.html",
"/**/*.css", "/**/*.css",
"/**/*.js" "/**/*.js"
).permitAll() ).permitAll()
.antMatchers("/profile/**").anonymous() .antMatchers("/profile/**").anonymous()
.antMatchers("/common/download**").anonymous() .antMatchers("/common/download**").anonymous()
.antMatchers("/common/download/resource**").anonymous() .antMatchers("/common/download/resource**").anonymous()
.antMatchers("/swagger-ui.html").anonymous() .antMatchers("/swagger-ui.html").anonymous()
.antMatchers("/swagger-resources/**").anonymous() .antMatchers("/swagger-resources/**").anonymous()
.antMatchers("/webjars/**").anonymous() .antMatchers("/webjars/**").anonymous()
.antMatchers("/*/api-docs").anonymous() .antMatchers("/*/api-docs").anonymous()
.antMatchers("/druid/**").anonymous() .antMatchers("/druid/**").anonymous()
// 除上面外的所有请求全部需要鉴权认证 // 除上面外的所有请求全部需要鉴权认证
.anyRequest().authenticated() .anyRequest().authenticated()
.and() .and()
.headers().frameOptions().disable(); .headers().frameOptions().disable();
httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler); httpSecurity.logout().logoutUrl("/logout").logoutSuccessHandler(logoutSuccessHandler);
// 添加JWT filter // 添加JWT filter
httpSecurity.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class); httpSecurity.addFilterBefore(authenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
} }
/** /**
* 强散列哈希加密实现 * 强散列哈希加密实现
*/ */
@Bean @Bean
public BCryptPasswordEncoder bCryptPasswordEncoder() public BCryptPasswordEncoder bCryptPasswordEncoder()
{ {
return new BCryptPasswordEncoder(); return new BCryptPasswordEncoder();
} }
/** /**
* 身份认证接口 * 身份认证接口
*/ */
@Override @Override
protected void configure(AuthenticationManagerBuilder auth) throws Exception protected void configure(AuthenticationManagerBuilder auth) throws Exception
{ {
auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder()); auth.userDetailsService(userDetailsService).passwordEncoder(bCryptPasswordEncoder());
} }
} }

64
ruoyi/src/main/java/com/ruoyi/framework/config/ServerConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/ServerConfig.java
View File

@ -1,32 +1,32 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;
import com.ruoyi.common.utils.ServletUtils; import com.uvaluation.common.utils.ServletUtils;
/** /**
* 服务相关配置 * 服务相关配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Component @Component
public class ServerConfig public class ServerConfig
{ {
/** /**
* 获取完整的请求路径，包括：域名，端口，上下文访问路径 * 获取完整的请求路径，包括：域名，端口，上下文访问路径
* *
* @return 服务地址 * @return 服务地址
*/ */
public String getUrl() public String getUrl()
{ {
HttpServletRequest request = ServletUtils.getRequest(); HttpServletRequest request = ServletUtils.getRequest();
return getDomain(request); return getDomain(request);
} }
public static String getDomain(HttpServletRequest request) public static String getDomain(HttpServletRequest request)
{ {
StringBuffer url = request.getRequestURL(); StringBuffer url = request.getRequestURL();
String contextPath = request.getServletContext().getContextPath(); String contextPath = request.getServletContext().getContextPath();
return url.delete(url.length() - request.getRequestURI().length(), url.length()).append(contextPath).toString(); return url.delete(url.length() - request.getRequestURI().length(), url.length()).append(contextPath).toString();
} }
} }

248
ruoyi/src/main/java/com/ruoyi/framework/config/SwaggerConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/SwaggerConfig.java
View File

@ -1,124 +1,124 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value; import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import io.swagger.annotations.ApiOperation; import io.swagger.annotations.ApiOperation;
import springfox.documentation.builders.ApiInfoBuilder; import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors; import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors; import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo; import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.ApiKey; import springfox.documentation.service.ApiKey;
import springfox.documentation.service.AuthorizationScope; import springfox.documentation.service.AuthorizationScope;
import springfox.documentation.service.Contact; import springfox.documentation.service.Contact;
import springfox.documentation.service.SecurityReference; import springfox.documentation.service.SecurityReference;
import springfox.documentation.spi.DocumentationType; import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext; import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket; import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2; import springfox.documentation.swagger2.annotations.EnableSwagger2;
/** /**
* Swagger2的接口配置 * Swagger2的接口配置
* *
* @author ruoyi * @author ruoyi
*/ */
@Configuration @Configuration
@EnableSwagger2 @EnableSwagger2
public class SwaggerConfig public class SwaggerConfig
{ {
/** 系统基础配置 */ /** 系统基础配置 */
@Autowired @Autowired
private RuoYiConfig ruoyiConfig; private RuoYiConfig ruoyiConfig;
/** 是否开启swagger */ /** 是否开启swagger */
@Value("${swagger.enabled}") @Value("${swagger.enabled}")
private boolean enabled; private boolean enabled;
/** 设置请求的统一前缀 */ /** 设置请求的统一前缀 */
@Value("${swagger.pathMapping}") @Value("${swagger.pathMapping}")
private String pathMapping; private String pathMapping;
/** /**
* 创建API * 创建API
*/ */
@Bean @Bean
public Docket createRestApi() public Docket createRestApi()
{ {
return new Docket(DocumentationType.SWAGGER_2) return new Docket(DocumentationType.SWAGGER_2)
// 是否启用Swagger // 是否启用Swagger
.enable(enabled) .enable(enabled)
// 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息） // 用来创建该API的基本信息，展示在文档的页面中（自定义展示的信息）
.apiInfo(apiInfo()) .apiInfo(apiInfo())
// 设置哪些接口暴露给Swagger展示 // 设置哪些接口暴露给Swagger展示
.select() .select()
// 扫描所有有注解的api，用这种方式更灵活 // 扫描所有有注解的api，用这种方式更灵活
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class)) .apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 扫描指定包中的swagger注解 // 扫描指定包中的swagger注解
// .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger")) // .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger"))
// 扫描所有 .apis(RequestHandlerSelectors.any()) // 扫描所有 .apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any()) .paths(PathSelectors.any())
.build() .build()
/* 设置安全模式，swagger可以设置访问token */ /* 设置安全模式，swagger可以设置访问token */
.securitySchemes(securitySchemes()) .securitySchemes(securitySchemes())
.securityContexts(securityContexts()) .securityContexts(securityContexts())
.pathMapping(pathMapping); .pathMapping(pathMapping);
} }
/** /**
* 安全模式，这里指定token通过Authorization头请求头传递 * 安全模式，这里指定token通过Authorization头请求头传递
*/ */
private List<ApiKey> securitySchemes() private List<ApiKey> securitySchemes()
{ {
List<ApiKey> apiKeyList = new ArrayList<ApiKey>(); List<ApiKey> apiKeyList = new ArrayList<ApiKey>();
apiKeyList.add(new ApiKey("Authorization", "Authorization", "header")); apiKeyList.add(new ApiKey("Authorization", "Authorization", "header"));
return apiKeyList; return apiKeyList;
} }
/** /**
* 安全上下文 * 安全上下文
*/ */
private List<SecurityContext> securityContexts() private List<SecurityContext> securityContexts()
{ {
List<SecurityContext> securityContexts = new ArrayList<>(); List<SecurityContext> securityContexts = new ArrayList<>();
securityContexts.add( securityContexts.add(
SecurityContext.builder() SecurityContext.builder()
.securityReferences(defaultAuth()) .securityReferences(defaultAuth())
.forPaths(PathSelectors.regex("^(?!auth).*$")) .forPaths(PathSelectors.regex("^(?!auth).*$"))
.build()); .build());
return securityContexts; return securityContexts;
} }
/** /**
* 默认的安全上引用 * 默认的安全上引用
*/ */
private List<SecurityReference> defaultAuth() private List<SecurityReference> defaultAuth()
{ {
AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything"); AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
AuthorizationScope[] authorizationScopes = new AuthorizationScope[1]; AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
authorizationScopes[0] = authorizationScope; authorizationScopes[0] = authorizationScope;
List<SecurityReference> securityReferences = new ArrayList<>(); List<SecurityReference> securityReferences = new ArrayList<>();
securityReferences.add(new SecurityReference("Authorization", authorizationScopes)); securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
return securityReferences; return securityReferences;
} }
/** /**
* 添加摘要信息 * 添加摘要信息
*/ */
private ApiInfo apiInfo() private ApiInfo apiInfo()
{ {
// 用ApiInfoBuilder进行定制 // 用ApiInfoBuilder进行定制
return new ApiInfoBuilder() return new ApiInfoBuilder()
// 设置标题 // 设置标题
.title("标题：若依管理系统_接口文档") .title("标题：若依管理系统_接口文档")
// 描述 // 描述
.description("描述：用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...") .description("描述：用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...")
// 作者信息 // 作者信息
.contact(new Contact(ruoyiConfig.getName(), null, null)) .contact(new Contact(ruoyiConfig.getName(), null, null))
// 版本 // 版本
.version("版本号:" + ruoyiConfig.getVersion()) .version("版本号:" + ruoyiConfig.getVersion())
.build(); .build();
} }
} }

124
ruoyi/src/main/java/com/ruoyi/framework/config/ThreadPoolConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/ThreadPoolConfig.java
View File

@ -1,62 +1,62 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.ThreadPoolExecutor;
import org.apache.commons.lang3.concurrent.BasicThreadFactory; import org.apache.commons.lang3.concurrent.BasicThreadFactory;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import com.ruoyi.common.utils.Threads; import com.uvaluation.common.utils.Threads;
/** /**
* 线程池配置 * 线程池配置
* *
* @author ruoyi * @author ruoyi
**/ **/
@Configuration @Configuration
public class ThreadPoolConfig public class ThreadPoolConfig
{ {
// 核心线程池大小 // 核心线程池大小
private int corePoolSize = 50; private int corePoolSize = 50;
// 最大可创建的线程数 // 最大可创建的线程数
private int maxPoolSize = 200; private int maxPoolSize = 200;
// 队列最大长度 // 队列最大长度
private int queueCapacity = 1000; private int queueCapacity = 1000;
// 线程池维护线程所允许的空闲时间 // 线程池维护线程所允许的空闲时间
private int keepAliveSeconds = 300; private int keepAliveSeconds = 300;
@Bean(name = "threadPoolTaskExecutor") @Bean(name = "threadPoolTaskExecutor")
public ThreadPoolTaskExecutor threadPoolTaskExecutor() public ThreadPoolTaskExecutor threadPoolTaskExecutor()
{ {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setMaxPoolSize(maxPoolSize); executor.setMaxPoolSize(maxPoolSize);
executor.setCorePoolSize(corePoolSize); executor.setCorePoolSize(corePoolSize);
executor.setQueueCapacity(queueCapacity); executor.setQueueCapacity(queueCapacity);
executor.setKeepAliveSeconds(keepAliveSeconds); executor.setKeepAliveSeconds(keepAliveSeconds);
// 线程池对拒绝任务(无线程可用)的处理策略 // 线程池对拒绝任务(无线程可用)的处理策略
executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
return executor; return executor;
} }
/** /**
* 执行周期性或定时任务 * 执行周期性或定时任务
*/ */
@Bean(name = "scheduledExecutorService") @Bean(name = "scheduledExecutorService")
protected ScheduledExecutorService scheduledExecutorService() protected ScheduledExecutorService scheduledExecutorService()
{ {
return new ScheduledThreadPoolExecutor(corePoolSize, return new ScheduledThreadPoolExecutor(corePoolSize,
new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build()) new BasicThreadFactory.Builder().namingPattern("schedule-pool-%d").daemon(true).build())
{ {
@Override @Override
protected void afterExecute(Runnable r, Throwable t) protected void afterExecute(Runnable r, Throwable t)
{ {
super.afterExecute(r, t); super.afterExecute(r, t);
Threads.printException(r, t); Threads.printException(r, t);
} }
}; };
} }
} }

3
ruoyi/src/main/java/com/ruoyi/framework/config/UVConfig.java → ruoyi/src/main/java/com/uvaluation/framework/config/UVConfig.java
View File

@ -1,6 +1,5 @@
package com.ruoyi.framework.config; package com.uvaluation.framework.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component; import org.springframework.stereotype.Component;

0
ruoyi/src/main/java/com/ruoyi/framework/config/properties/DruidProperties.java → ruoyi/src/main/java/com/uvaluation/framework/config/properties/DruidProperties.java
View File

50
ruoyi/src/main/java/com/ruoyi/framework/datasource/DynamicDataSource.java → ruoyi/src/main/java/com/uvaluation/framework/datasource/DynamicDataSource.java
View File

@ -1,26 +1,26 @@
package com.ruoyi.framework.datasource; package com.uvaluation.framework.datasource;
import java.util.Map; import java.util.Map;
import javax.sql.DataSource; import javax.sql.DataSource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/** /**
* 动态数据源 * 动态数据源
* *
* @author ruoyi * @author ruoyi
*/ */
public class DynamicDataSource extends AbstractRoutingDataSource public class DynamicDataSource extends AbstractRoutingDataSource
{ {
public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources)
{ {
super.setDefaultTargetDataSource(defaultTargetDataSource); super.setDefaultTargetDataSource(defaultTargetDataSource);
super.setTargetDataSources(targetDataSources); super.setTargetDataSources(targetDataSources);
super.afterPropertiesSet(); super.afterPropertiesSet();
} }
@Override @Override
protected Object determineCurrentLookupKey() protected Object determineCurrentLookupKey()
{ {
return DynamicDataSourceContextHolder.getDataSourceType(); return DynamicDataSourceContextHolder.getDataSourceType();
} }
} }

Some files were not shown because too many files have changed in this diff Show More