HiC Pro 环境配置及使用（hid-core.c）

25-01-23 29

如果您对HiCPro环境配置及使用和hid-core.c感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解HiCPro环境配置及使用的各种细节，并对hid-core.c进行深入的分析，此外还有关于

如果您对HiC Pro 环境配置及使用和hid-core.c感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解HiC Pro 环境配置及使用的各种细节，并对hid-core.c进行深入的分析，此外还有关于.net core 环境配置及运行、2.8-bash环境配置及脚本、87-springboot+shiro+redis的配置及使用、cwRsync 在 windows 环境下的配置及使用的实用技巧。

本文目录一览：

HiC Pro 环境配置及使用（hid-core.c）
.net core 环境配置及运行
2.8-bash环境配置及脚本
87-springboot+shiro+redis的配置及使用
cwRsync 在 windows 环境下的配置及使用

HiC Pro 环境配置及使用（hid-core.c）

HiC Pro 是一组基因组分析套件，可提供 HiC 相关的分析。

配置运行时环境

Python 环境和 Docker 环境二选一即可。

Python 环境

安装 miniconda

# down miniconda
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-py39_4.12.0-Linux-x86_64.sh

# install miniconda
bash Miniconda3-latest-Linux-x86_64.sh

# activate conda
source .bashrc

可以从清华源获取新的版本：https://mirror.tuna.tsinghua.edu.cn/help/anaconda/

安装 HicPro

# download hic pro
wget https://github.com/nservant/HiC-Pro/archive/refs/tags/v3.1.0.tar.gz

# decompression
tar zxf v3.1.0.tar.gz

# 根据 HiC Pro 项目中的配置文件创建一个全新的环境
conda env create -f HiC-Pro-3.1.0/environment.yml

# 激活 HiC-Pro Python 环境
conda activate HiC-Pro_v3.1.0

# 可选，AWS Ubuntu 需要安装
apt install g++ unzip

# 生成配置，执行安装
make configure
make

可以从 HicPro Release 页面获取新的版本： https://github.com/nservant/HiC-Pro/releases
注意程序的安装目录为 解压文件 所在目录的

Docker 环境

安装 Docker：

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

根据提示操作，等待执行完成。

配置镜像加速，如果文件不存在则创建，如果文件已经存在，则在 registry-mirrors 添加镜像地址。

vim /etc/docker/daemon.json

添加腾讯云镜像加速：

{
   "registry-mirrors": [
       "https://mirror.ccs.tencentyun.com"
  ]
}

启动 Docker，启动一次，后续开机自动启动，无需操作

# 设置 Docker 开机启动
sudo systemctl enable docker
# 启动 Docker 运行时
sudo systemctl start docker
# 可选，脚本以自动添加
sudo groupadd docker
# 为当前用户添加 docker 执行权限，root 用户跳过
sudo usermod -aG docker $USER

拉取 hicpro 镜像：

docker pull nservant/hicpro:latest

如果需要进入 Hic Pro 的运行环境，可通过下方命令，进入 bash 环境，执行后续的文件转换操作。

# 运行
docker run -it -v /mnt/cosfs/PM_XS05KF2020110270_55_MGI:/data nservant/hicpro bash

-it 代表需要控制台命令操作； -v 代表挂载目录，本地目录：运行环境目录

如果已经准备好所有的分析文件，并完成 config-hicpro.txt 文件的修改，可直接运行下面的命令，Hic Pro 分析进程将直接进入后台操作，分析完成后退出。

期间可通过，docker top 或者 htop 等命令查看进程运行情况，或通过 docker logs -f hicpro 命令查看控制台日志，当然也可以查看 analysis 目录下 log 文件。

docker run --name=hicpro -d -v /mnt/cosfs/PM_XS05KF2020110270_55_MGI:/data nservant/hicpro /HiC-Pro_3.0.0/bin/HiC-Pro -c /data/E234/config-hicpro.txt -o /data/E234/analysis -i /data/E234/data

-d 代表程序进入后台运行；—name 代表 docker 运行时名称；-v 代表挂载目录（可挂载多个路径）；
nservant/hicpro 代表镜像名称；

/HiC-Pro_3.0.0/bin/HiC-Pro 代表 HiC Pro 可执行文件的文件路径；其后相关参数，均为 Hic Pro 程序的参数。

-c 为容器内 config-hicpro.txt 文件路径（需注意是 docker 内部挂载后的路径）；
-o 为文件输出输出结果所在路径（路径保存在容器内部，如果需要保存到本地，需保存在 -v` 挂载的路径内）；
-i 为 config-hicpro.txt 内部引用数据的目录（fasta 和 bowtie index 所在路径）

如下部分为 Hic Pro 程序参数：

/HiC-Pro_3.0.0/bin/HiC-Pro -c /data/E234/config-hicpro.txt -o analysis -i /data/E234/data

Hic Pro 使用

如果已经完成 config-hicpro.txt 的相关配置和文件的生成，可跳过参数文件章节。

参数文件

生成 bowtie2 index 文件。

bowtie2-build --threads 16 Homo_sapiens_assembly19.fasta E234

E234 为生成文件的前缀

整理基因组文件，生成 bed 文件

/HiC-Pro-3.1.0/bin/utils/digest_genome.py Homo_sapiens_assembly19.fasta -r dpnii -o E234_dpnii.bed

/HiC-Pro-3.1.0 为 HiC Pro 所在目录，可根据使用章节中的介绍判断，例子中为 Docker 环境中的所做目录。
-o 为生成 bed 文件的文件名

建立 .fai 文件，根据这个 .fai 文件和原始的 fastsa 文件，能够快速的提取任意区域的序列。

该命令对输入的 fasta 序列有一定要求：对于每条序列，除了最后一行外，其他行的长度必须相同。

samtools faidx Homo_sapiens_assembly19.fasta

生成的文件名为 fasta 文件的文件名加 .fai 文件后缀，如上例子中得到： Homo_sapiens_assembly19.fasta.fai

根据 fai 文件，提取基因对照组，即 .sizes 文件

awk ''{print $1"\t" $2}'' Homo_sapiens_assembly19.fasta.fai >genome.sizes

如果你拿到的是 bam 文件，需要生产 fastq 文件，可通过下面的文件生成 fastq 文件。

bedtools bamtofastq -i E234_R1_2.hicup.bam -fq E234_R1_2.fastq

HiC Pro 使用

首先确定 HiC Pro 的所在目录，例如 Python 环境时，下载文件和解压文件所做的目录（例如在用户家目录中安装，则为： ~/HiC-Pro-3.1.0），如果是 Docker 环境: /HiC-Pro_3.1.0 (注意 3.1.0 为软件版本，后续可能改变，可通过 ls 查看根目录下判断得出具体目录)

/HiC-Pro_3.0.0/bin/HiC-Pro -c /data/E234/config-hicpro.txt -o analysis -i /data/E234/data

如上命令执行分析，-c 为配置文件在路径， -o 为分析结果存放目录，-i 为分析文件所在目录（fasta 所在目录）

相关参考链接

https://lxz9.com/2021/07/18/HiC-Pro/
https://cloud.tencent.com/developer/article/1938221
https://cloud.tencent.com/developer/article/1556867
https://www.omicsclass.com/article/751

.net core 环境配置及运行

开发环境：VS 2017 Enterprise

C:\Users\Administrator>dotnet --info
.NET Core SDK（反映任何 global.json）:
 Version:   2.2.102
 Commit:    96ff75a873

运行时环境:
 OS Name:     Windows
 OS Version:  6.1.7601
 OS Platform: Windows
 RID:         win7-x64
 Base Path:   C:\Program Files\dotnet\sdk\2.2.102\

Host (useful for support):
  Version: 2.2.2
  Commit:  a4fd7b2c84

.NET Core SDKs installed:
  2.1.202 [C:\Program Files\dotnet\sdk]
  2.1.502 [C:\Program Files\dotnet\sdk]
  2.1.503 [C:\Program Files\dotnet\sdk]
  2.2.102 [C:\Program Files\dotnet\sdk]

.NET Core runtimes installed:
  Microsoft.AspNetCore.All 2.1.6 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.All 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.All 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.All 2.2.2 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.App 2.1.6 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.AspNetCore.App 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.AspNetCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.AspNetCore.App 2.2.2 [C:\Program Files\dotnet\shared\Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 2.0.9 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.1.6 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.1.7 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.2.1 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.2.2 [C:\Program Files\dotnet\shared\Microsoft.NETCore.App]

To install additional .NET Core runtimes or SDKs:
  https://aka.ms/dotnet-download

C:\Users\Administrator>dotnet --version
2.2.102

C:\Users\Administrator>

部署环境：CentOS7  nginx+Supervisor+.net core

[root@localhost ~]# dotnet --info
.NET Core SDK (reflecting any global.json):
 Version:   2.2.104
 Commit:    73f036d4ac

Runtime Environment:
 OS Name:     centos
 OS Version:  7
 OS Platform: Linux
 RID:         centos.7-x64
 Base Path:   /root/dotnet/sdk/2.2.104/

Host (useful for support):
  Version: 2.2.2
  Commit:  a4fd7b2c84

.NET Core SDKs installed:
  2.2.102 [/root/dotnet/sdk]
  2.2.104 [/root/dotnet/sdk]

.NET Core runtimes installed:
  Microsoft.AspNetCore.All 2.2.1 [/root/dotnet/shared/Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.All 2.2.2 [/root/dotnet/shared/Microsoft.AspNetCore.All]
  Microsoft.AspNetCore.App 2.2.1 [/root/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.AspNetCore.App 2.2.2 [/root/dotnet/shared/Microsoft.AspNetCore.App]
  Microsoft.NETCore.App 2.2.1 [/root/dotnet/shared/Microsoft.NETCore.App]
  Microsoft.NETCore.App 2.2.2 [/root/dotnet/shared/Microsoft.NETCore.App]

To install additional .NET Core runtimes or SDKs:
  https://aka.ms/dotnet-download
[root@localhost ~]# dotnet --version
2.2.104
[root@localhost ~]#

运行正常！

2.8-bash环境配置及脚本

bash的配置文件

按生效范围划分：存在两类

全局配置：

/etc/profile

/etc/profile.d/*.sh

/etc/bashrc

个人配置：

~/.bash_profile

~/.bashrc

按功能划分，存在两类：

profile类：为交互式登录的shell提供配置

全局：/etc/profile,/etc/profile.d/*.sh

个人：~/.bash_profile

功用：

1.用于定义环境变量

2.运行命令或脚本

bashrc类：为非交互式登录的shell提供配置

全局：/etc/bashrc

个人：~/.bashrc

功用：

1.定义命令别名

2.定义本地变量

shell登录：

交互式登录：

1.直接通过终端输入账号密码登录

2.使用"su - username"或"su -l username"切换的用户

读取顺序

/etc/profile --> /etc/profile.d/*.sh --> ~/.bash_profile --> ~/.bashrc --> /etc/bashrc

非交互式登录：

1.su username

2.图形界面下打开的终端

3.执行脚本

~/.bashrc --> /etc/bashrc --> /etc/profile.d/*.sh

编辑配置文件定义的新配置的生效方式：

1.重新启动shell进程

2.使用source或.命令进程

Note:使用source或.执行会有些副作用，比如设定在~/.bash_profile中的个人环境变量会重复赋值

bash中的算数运算

+,-,*,/,%,**......

# help let

实现算术运算：

1.let var=算式表达式

2.var=$[算术表达式]

3.var=$((算术表达式))

4.var=$(expr arg1 arg2...)

乘法符号须转义例如：mul=$(expr $num1 \* $num2)

bash有内建的随机数生成器：$RANDOM（生成1-32767的随机数）

增强型赋值：

+=,-=,*=,/=,%=

let varOPERvalue

例如：

count=$[$count+1]可以写成let count+=1或count++

自增，自减

let var+=1

let var++

let var-=1

let var--

练习1：写一个脚本

计算/etc/passwd文件中的第10个用户和第20个用户的ID之和

练习2：写一个脚本

传递两个文件路径路径作为参数给脚本，计算这两个文件中所有空白行之和

练习3：统计/etc,/var,/usr目录共有多少个一级子目录和文件

条件测试：

判断某需求是否满足，需要由测试机制来实现：

Note:专用的测试表达式需要由测试命令辅助完成测试过程

测试命令：

test EXPRESSION

[ EXPRESSION ]

[[ EXPRESSION ]]

Note:EXPRESSION前后必须有空白字符

bash的测试类型：

数值测试：

-gt：是否大于

-ge：是否大于等于

-eq：是否等于

-ne：是否不等于

-lt：是否小于

-le：是否小于等于

字符串测试：

==/=：是否等于

>：是否大于

<：是否小于

!=：是否不等于

=~：左侧的字符串是否能够被右侧的PATTERN所匹配到

Note:此表达式一般用于[[ ]]中

-z "STRING"：测试字符串是否为空，空则为真，不空则为假

-n "STRING"：测试字符串是否不空，不空为真，空则为假

Note：用于字符串比较时用到的字符串要使用引号

bash自定义退出状态码

exit [n]：自定义退出状态码

注意1：脚本中一旦遇到exit命令，脚本会立即终止，终止退出状态取决于exit命令后面的数字

注意2：如果未给脚本指定退出状态码，整个脚本的退出状态码取决于脚本中执行的最后一条命令的状态码

练习：写一个脚本

接受一个文件路径作为参数：

如果参数个数小于1，则提示用户“至少应该给一个参数”，并立即退出

如果参数不小于1，则显示第一个参数所指向的文件的空白行数

87-springboot+shiro+redis的配置及使用

application-dev.yml

server:
  port: 8080
  servlet:
    context-path: /
ip:
  mysql: localhost:3306
  localhost: localhost


spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://${ip.mysql}/kuma?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver

  redis:
    host: ${ip.localhost}
    port: 6379
    jedis:
      pool:
        max-idle: 8
        min-idle: 0
        max-active: 8
        max-wait: -1
    timeout: 0
#  jpa:
#    hibernate:
#      ddl-auto: none
#    show-sql: true
  thymeleaf:
    cache: false

  devtools:
    restart:
      enabled: false
#      additional-paths: resources/**,static/**,templates/**,src/main/java

  resources:
    static-locations: classpath:/static/, classpath:/templates/

#  cache:
#    ehcache:
#      config: classpath:ehcache.xml
#
  cache:
    type: simple
  # 每次应用启动不检查Activiti数据表是否存在及版本号是否匹配，提升应用启动速度
#  activiti:
#    database-schema-update: false
#    history-level: full
#    font:
#      activityFontName: 宋体
#      labelFontName: 宋体
#    check-process-definitions: true


mybatis:
  mapper-locations: classpath:mapping/**/*.xml
  type-aliases-package: com.kuma.platform.model

#zookeeper:
#  address: 127.0.0.1:2181
#  timeout: 4000

#showSql
logging:
  level:
    com:
      kuma:
        platform:
          dao: debug

upload:
  server:
    domain: http://${ip.localhost}:${server.port}${server.servlet.context-path}
  image:
    dir: D:/upload/images
    format: swf,wmv,gif,png,jpg,jpeg,bmp
    size: 151200000
  file:
    dir: D:/upload/file
  video:
    dir: D:/upload/video

SpringShiroConfig.java

package com.kuma.platform.config;

import at.pollux.thymeleaf.shiro.dialect.ShiroDialect;
import com.kuma.platform.shiro.CustomRealm;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.LifecycleBeanPostProcessor;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.CookieRememberMeManager;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.apache.shiro.web.servlet.SimpleCookie;
import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
import org.crazycake.shiro.RedisCacheManager;
import org.crazycake.shiro.RedisManager;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.MethodInvokingFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;

import java.util.LinkedHashMap;
import java.util.Map;

@Configuration
public class SpringShiroConfig {

	@Value("${spring.redis.host}")
	String host;
	@Value("${spring.redis.port}")
	int port;
	@Value("${spring.redis.timeout}")
	private int timeout;

	@Autowired
	private CustomRealm realm;

	public SpringShiroConfig() {
		System.out.println("SpringShiroConfig init ......");
	}
	@Bean(name = "lifecycleBeanPostProcessor")
	public static LifecycleBeanPostProcessor getLifecycleBeanPostProcessor() {
		return new LifecycleBeanPostProcessor();
	}

	@Bean
	@DependsOn("lifecycleBeanPostProcessor")
	public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator() {
		DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();
		creator.setProxyTargetClass(true);
//		creator.setUsePrefix(true);
		return creator;
	}


	@Bean
	public MethodInvokingFactoryBean getMethodInvokingFactoryBean(@Qualifier("securityManager")SecurityManager securityManager) {
		MethodInvokingFactoryBean methodInvokingFactoryBean=new MethodInvokingFactoryBean();
		methodInvokingFactoryBean.setStaticMethod("org.apache.shiro.SecurityUtils.setSecurityManager");
		methodInvokingFactoryBean.setArguments(securityManager);
		return methodInvokingFactoryBean;
	}



	//get
	@Bean
	public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager")SecurityManager securityManager) {
		AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
		authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
		return authorizationAttributeSourceAdvisor;
	}


	//get
	@Bean(name = "shiroFilter")
	public ShiroFilterFactoryBean shiroFilterFactoryBean(@Qualifier("securityManager")SecurityManager securityManager){
		ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
		shiroFilterFactoryBean.setLoginUrl("/logon");
		shiroFilterFactoryBean.setUnauthorizedUrl("/logon");
		shiroFilterFactoryBean.setSuccessUrl("/index");
//		shiroFilterFactoryBean.setLoginUrl("/user/login.html");
//		shiroFilterFactoryBean.setUnauthorizedUrl("/user/login.html");
		shiroFilterFactoryBean.setSecurityManager(securityManager);

		loadShiroFilterChain(shiroFilterFactoryBean);

		return shiroFilterFactoryBean;
	}
	//get
	private void loadShiroFilterChain(ShiroFilterFactoryBean shiroFilterFactoryBean) {
		Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
		filterChainDefinitionMap.put("/layuiadmin/**", "anon");

		filterChainDefinitionMap.put("/login.html", "anon");
		filterChainDefinitionMap.put("/**/login/**", "anon");
		filterChainDefinitionMap.put("/api/**", "anon");
		filterChainDefinitionMap.put("/logon", "anon");
		filterChainDefinitionMap.put("/logout", "anon");
		filterChainDefinitionMap.put("/", "anon");

		filterChainDefinitionMap.put("/index", "user");
		filterChainDefinitionMap.put("/index.html", "user");


		filterChainDefinitionMap.put("/**", "authc");

		/*
		 * filterChainDefinitionMap.put("/mydemo/login", "anon");
		 * filterChainDefinitionMap.put("/user/info**", "authc");
		 * filterChainDefinitionMap.put("/admin/listUser**","authc,perms[admin:manage]");
		 */

		shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
	}

	//get
	@Bean(name = "sessionManager")
	public DefaultWebSessionManager sessionManager(){
		DefaultWebSessionManager sessionManager = new DefaultWebSessionManager();
		sessionManager.setCacheManager(cacheManager());
		sessionManager.setGlobalSessionTimeout(1000*60);//单位：毫秒
//		sessionManager.setDeleteInvalidSessions(true);
		sessionManager.setSessionIdCookieEnabled(true);
		sessionManager.setSessionDAO(redisSessionDAO());
		return sessionManager;
	}


	//get
	@Bean(name = "securityManager")
	public DefaultWebSecurityManager securityManager(@Qualifier("sessionManager") DefaultWebSessionManager sessionManager) {
		DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
		securityManager.setRealm(realm);
		securityManager.setSessionManager(sessionManager);
		securityManager.setCacheManager(cacheManager());
		securityManager.setRememberMeManager(rememberMeManager());
		return securityManager;
	}


	public SimpleCookie rememberMeCookie() {
		// 这个参数是cookie的名称，对应前端的checkbox的name = rememberMe
		SimpleCookie simpleCookie = new SimpleCookie("rememberMe");
		// 记住我cookie生效时间30天 ,单位秒。 注释掉，默认永久不过期 2018-07-15
        simpleCookie.setMaxAge(60*60);
		return simpleCookie;
	}
	/**
	 * cookie管理对象;记住我功能
	 *
	 * @return
	 */
	public CookieRememberMeManager rememberMeManager() {
		CookieRememberMeManager cookieRememberMeManager = new CookieRememberMeManager();
		cookieRememberMeManager.setCookie(rememberMeCookie());
		//rememberMe cookie加密的密钥 建议每个项目都不一样 默认AES算法 密钥长度(128 256 512 位)
//		cookieRememberMeManager.setCipherKey(Base64.decode("1QWLxg+NYmxraMoxAXu/Iw=="));
		return cookieRememberMeManager;
	}

	//为了在thymeleaf里使用shiro的标签的bean
	@Bean
	public ShiroDialect shiroDialect() {
		return new ShiroDialect();
	}


	/**
	 * cacheManager 缓存 redis实现
	 * 使用的是shiro-redis开源插件
	 *
	 * @return
	 */
	public RedisCacheManager cacheManager() {
		RedisCacheManager redisCacheManager = new RedisCacheManager();
		redisCacheManager.setRedisManager(redisManager());
		return redisCacheManager;
	}

	/**
	 * 配置shiro redisManager
	 * 使用的是shiro-redis开源插件
	 *
	 * @return
	 */
	public RedisManager redisManager() {
		RedisManager redisManager = new RedisManager();
		redisManager.setHost(host);
		redisManager.setPort(port);
		redisManager.setExpire(1800);// 配置缓存过期时间
		redisManager.setTimeout(timeout);
		return redisManager;
	}

	/**
	 * RedisSessionDAO shiro sessionDao层的实现 通过redis
	 * 使用的是shiro-redis开源插件
	 */
	@Bean
	public RedisSessionDAO redisSessionDAO() {
		RedisSessionDAO redisSessionDAO = new RedisSessionDAO();
		redisSessionDAO.setRedisManager(redisManager());
		return redisSessionDAO;
	}

}

CustomRealm.java

package com.kuma.platform.shiro;

import com.kuma.platform.model.po.admin.AdminMenuPo;
import com.kuma.platform.model.po.admin.AdminUserPo;
import com.kuma.platform.service.admin.AdminMenuService;
import com.kuma.platform.service.admin.AdminUserService;
import com.kuma.platform.utils.RedisApiUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 自定义Realm
 * @author super_dev_001
 * @date 2020/4/6
 * @param
 * @return
 */
@Component
public class CustomRealm extends AuthorizingRealm {
	@Autowired
	private AdminUserService adminUserService;
	@Autowired
	private AdminMenuService adminMenuService;


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

	public CustomRealm() {
		logger.info("CustomRealm====================");
	}


	@Override
	public String getName() {
		return "CustomRealm";
	}

	@Bean(name = "credentialsMatcher")
	public HashedCredentialsMatcher credentialsMatcher(){
		HashedCredentialsMatcher credentialsMatcher = new HashedCredentialsMatcher();
		credentialsMatcher.setHashAlgorithmName("md5");
		credentialsMatcher.setHashIterations(1024);
		return credentialsMatcher;
	}

	@Override
	public void setCredentialsMatcher(@Qualifier("credentialsMatcher")CredentialsMatcher credentialsMatcher){
		super.setCredentialsMatcher(credentialsMatcher);
	}

	/**
	 * realm授权方法 从输入参数principalCollection得到身份信息 根据身份信息到数据库查找权限信息 将权限信息添加给授权信息对象
	 * 返回 授权信息对象(判断用户访问url是否在权限信息中没有体现)
	 */
	@Override
	protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
		AdminUserPo user = null;
//		AdminUserPo user = (AdminUserPo) principalCollection.getPrimaryPrincipal();

		Long userId = (Long)principalCollection.getPrimaryPrincipal();

		List<String> btnList = null;
		try{
			user = this.adminUserService.queryById(userId);
			String roleIds = user.getRoleIds();
			btnList = adminMenuService.queryBtnsByRoles(roleIds);
		}catch (Exception e){
			e.printStackTrace();
		}
		// 用户权限列表
		Set<String> permsSet = new HashSet<String>();
		if(btnList!=null && btnList.size()>0){
			permsSet.addAll(btnList);
		}
		SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
		info.setStringPermissions(permsSet);
		return info;
	}

	/**
	 * 表单认证过滤器认证时会调用自定义Realm的认证方法进行认证，成功回到index.do，再跳转到index.jsp页面
	 *
	 * 前提：表单认证过滤器收集和组织用户名和密码信息封装为token对象传递给此方法
	 *
	 * token:封装了身份信息和凭证信息 2步骤：比对身份 信息；比对凭证
	 */
	@Override
	protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {
		UsernamePasswordToken upToken = (UsernamePasswordToken) token;
		String username = upToken.getUsername();
		String password = new String((char[]) token.getCredentials());

		// 查询用户信息
		AdminUserPo adminUserPo = null;
		try{
			adminUserPo = adminUserService.queryByUserName(username);
		}catch (Exception e){
			e.printStackTrace();
		}

		// 账号不存在
		if (adminUserPo == null ) {
			throw new UnknownAccountException("账号不存在!");
		}
		// 密码错误
		if (!password.equals(adminUserPo.getPassword())) {
			throw new IncorrectCredentialsException("账号或密码不正确!");
		}

		// 账号未分配角色
		if (adminUserPo.getRoleIds() == null ) {
			throw new UnknownAccountException("账号未分配角色!");
		}

		//super_dev_001 2020/2/8 登录成功，查询菜单
		try{
			List<AdminMenuPo> menuList = this.adminMenuService.queryByRoles(adminUserPo.getRoleIds());
			adminUserPo.setMenuList(menuList);
			RedisApiUtils.save(""+adminUserPo.getId(),adminUserPo);
//			EhcacheUtils.putUser(adminUserPo);
		}catch (Exception e){
			e.printStackTrace();
		}
		SimpleAuthenticationInfo info = new SimpleAuthenticationInfo(adminUserPo.getId(), password, ByteSource.Util.bytes(username), getName());
		return info;
	}
}

ShiroUtils.java

package com.kuma.platform.shiro;

import com.alibaba.fastjson.JSON;
import com.kuma.platform.model.po.admin.AdminUserPo;
import com.kuma.platform.utils.RedisApiUtils;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;

/**
 * super_dev_001 2020/2/3
 */
public class ShiroUtils {
    public static Session getSession() {
        return SecurityUtils.getSubject().getSession(true);
    }

    public static Subject getSubject() {
        return SecurityUtils.getSubject();
    }

    public static AdminUserPo getUserEntity() {
        Long userId = (Long)getSubject().getPrincipal();
        Object userObj = RedisApiUtils.get(""+userId);

        if(userObj!=null){
            AdminUserPo rec = JSON.parseObject(JSON.toJSONString(userObj),AdminUserPo.class);
            return rec;
        }
        return null;
    }

    public static Long getUserId() {
        return getUserEntity()==null?null:getUserEntity().getId();
    }
    public static String getUserName() {
        return getUserEntity()==null?null:getUserEntity().getUserName();
    }

    public static void setSessionAttribute(Object key, Object value) {
        getSession().setAttribute(key, value);
    }

    public static Object getSessionAttribute(Object key) {
        return getSession().getAttribute(key);
    }

    public static boolean isLogin() {
        return SecurityUtils.getSubject().getPrincipal() != null;
    }

    public static void logout() {
        RedisApiUtils.del(""+getUserId());
        SecurityUtils.getSubject().logout();

//        EhcacheUtils.removeUser();
    }

    public static String getKaptcha(String key) {
        String kaptcha = getSessionAttribute(key).toString();
        getSession().removeAttribute(key);
        return kaptcha;
    }
}

RedisApiUtils.java

package com.kuma.platform.utils;

import com.alibaba.fastjson.JSON;
import org.crazycake.shiro.RedisSessionDAO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import javax.annotation.PostConstruct;


/**
 * super_dev_007 2020/11/26
 */
@Component
public class RedisApiUtils{

    @Value("${spring.redis.host}")
    String host;
    @Value("${spring.redis.port}")
    int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;
    @Value("${spring.redis.jedis.pool.max-wait}")
    private long maxWaitMillis;

    @Autowired
    RedisSessionDAO redisSessionDAO;

    @Autowired
    JedisPool jedisPool;

    Jedis jedis;

    public static String pre = "re_";

    @Bean
    public JedisPool redisPoolFactory() {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        jedisPoolConfig.setMaxIdle(maxIdle);
        jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

        JedisPool jedisPool = new JedisPool(jedisPoolConfig, host, port, timeout);

        return jedisPool;
    }


    private static RedisApiUtils staticInstance = new RedisApiUtils();
    @PostConstruct
    public void init(){
        staticInstance.redisSessionDAO = redisSessionDAO;
        staticInstance.jedisPool = jedisPool;
        staticInstance.jedis = jedisPool.getResource();
    }


    public static Object get(String key){
        String value = staticInstance.jedis.get(pre+key);
        return JSON.parseObject(value);
    }

    public static void save(String key,Object value){
        staticInstance.jedis.set(pre+key,JSON.toJSONString(value));
    }

    public static void del(String key){
        staticInstance.jedis.del(pre+key);
    }

}

最后是登录方法：

@RequestMapping(value = "login")
	@ResponseBody
	public Object login(@ModelAttribute("user") LoginUser user, HttpServletRequest request, Model model, HttpSession session) {
		BaseResp resp = new BaseResp();

		String access_token = "" + IdUtils.id();
		JSONObject jsonObject = new JSONObject();
		/**
		 * 使用Shiro编写认证操作
		 */
		try {
			Subject subject = SecurityUtils.getSubject();
			UsernamePasswordToken token = new UsernamePasswordToken(user.getUserName(),
					CommonUtils.md5(user.getPassword()),user.getRememberMe());
			subject.login(token);

			AdminUserPo adminUserPo = ShiroUtils.getUserEntity();

			jsonObject.put("access_token", access_token);
			jsonObject.put("user", rtnUser(adminUserPo));
			resp.setData(jsonObject);

			model.addAttribute("user",adminUserPo);
		} catch (UnknownAccountException e) {
			resp.setSuccess(false);
			resp.setMsg(e.getMessage());
		} catch (IncorrectCredentialsException e) {
			resp.setSuccess(false);
			resp.setMsg(e.getMessage());
		} catch (Exception e) {
			e.printStackTrace();
			resp.setSuccess(false);
			resp.setMsg("系统异常，请稍后再试");
		}
		return resp;
	}

cwRsync 在 windows 环境下的配置及使用

关于 cwRsync 的作用在此不再过多描述，在整个调研过程中，网上搜索了很多的相关资料，配置过程中也出现了很多细节问题，所以在这里主要针对配置过程中需要注意的地方进行提醒，以及对关键的配置操作进行说明。

说明：

两台电脑，我这里用虚拟机（XP）模拟服务端，用本机（win7）模拟客户端。
服务端 IP：192.168.137.232；本机 IP：192.168.137.134。

实现目的：将服务端 C:\data 目录中的文件定时同步到客户端 D:\data 目录中去。

cwRsyncServer（服务端）配置步骤：

1. 解压 cwRsyncServer_4.1.0_fuq.zip，双击 cwRsyncServer_4.1.0_Installer.exe。

2. 按照安装提示，逐步操作至创建账户的界面，如下图所示。ps：这里创建的账户是操作系统的，创建的这个账户是专门用来运行 cwRsyncServer 服务端程序的。建议这里不要使用安装程序默认提供的账户名和密码，不易记忆，应该创建一个自己常用的、容易记住的账户。当然也可以使用操作系统中已经存在的账户，但这里个人感觉还是创建一个专门的针对 cwRsyncServer 的账户较好，在今后的管理中方便明了。我这里新建了一个 “tongbu” 的账户。

3.cwRsyncServer 服务程序安装成功后，关闭窗口。然后在系统服务管理界面中找到 RsyncServer 项，将其启动类型改为 “自动”，接着启动服务。

4. 这一步的操作很重要，需要强调。服务端 C:\data 目录中的文件需要 cwRsyncServer 服务程序来维持同步，而我创建的 “tongbu” 账户是来运行 cwRsyncServer 服务程序的，所以 “tongbu” 账户需要对 C:\data 这个目录有足够的操作权限。这就需要我们来设置一下。

5. 权限设置完后，修改 cwRsyncServer 的配置文件（安装目录 \ICW\rsyncd.conf）。下图是我应用的配置项，未用到配置项的说明可以到官网查询。

ps：上图中指定的用户名和密码，可以随意指定的，客户端匹配时也得指定成这里设置的用户名和密码。不像网上有些资料描述的那样，都设置成了安装时所创建的操作系统的账户和密码。

6. 按照配置文件中的指定，需要在 rsyncd.conf 文件所在的目录下创建密码文件 ——rsync.password。内容为 “用户名：密码”，即 “userdata:123456”。至此服务端的同步配置已经完成了。

cwRsync 客户端的配置步骤：

1. 在客户端的机器上解压 cwRsync_4.1.0_kh.zip 后，点击 cwRsync_4.1.0_Installer.exe。

2. 按照安装程序的提示，逐步点击，直到提示安装成功为止。这里安装过程简单不再截图。

3. 测试客户端与服务端的连接是否正常。开始 -> 运行 ->cmd，在命令行中输入如下内容：

telnet 192.168.137.232 873

其中 873 是 cwRsyncServer 默认的端口号，我们也可以在服务端的配置文件进行其他端口的指定使用。

4. 若客户端与服务端连接成功，会如下图所示。

如果连接不成功，请查看服务端的防火墙，确保防火墙不阻止 873 端口的访问。

5. 在客户端创建执行脚本文件，其中写入连接服务端进行同步的命令。在安装目录 \cwRsync\bin 目录下新建 fileRsync.cmd 文件，内容如下。当然创建成批量文件 (.bat) 也是可以的。这里我发现 cwRsync 客户端程序安装完后，我当前登录使用的账户是没有权限在安装目录 \cwRsync\bin 下创建文件的，所以我将安装目录 \cwRsync 和安装目录 \cwRsync\bin 都设定成了我当前登录的账户可以完全控制，具体操作参考上面服务端的权限设定说明。

rsync --port=873 -vzrtopg --progress --delete --password-file=/cygdrive/c/pass/rsync.password userdata@192.168.137.232::t_files /cygdrive/e/test-files

文件中只写了 rsync 这条执行命令，那么则需要将安装目录 \cwRsync\bin 设置到环境变量 path 中去。否则在脚本文件中的命令如下。

cd C:\Program Files (x86)\cwRsync\bin
rsync --port=873 -vzrtopg --progress --delete --password-file=/cygdrive/c/pass/rsync.password userdata@192.168.137.232::t_files /cygdrive/e/test-files

在 rsync 的执行命令中，有很多的配置选项，这些可以参考官方文档。另外还需要注意几点。

userdata 就是对应在服务端配置文件中指定的身份验证的用户名。
t_files 就是在服务端配置文件中指定的模块名称。
/cygdrive/e/test-files 指定将服务端文件同步到客户端的目录。
--password-file 指明客户端的身份验证密码文件，跟服务端的那个密码文件是对应的。只不过客户端的密码文件中不需要写认证用户名。这里注意，我在设置的过程中发现密码文件路径中不能有空格，不然会造成命令解析错误的。所以我单独把密码文件放到了 c:\pass 目录下。

6. 既然上面提到了客户端也需要和服务端对应的密码文件，那么我们需要创建密码文件，在 c:\pass 目录创建 rsync.password 文件，内容为 “123456”。

7. 在命令行中运行脚本文件，同时观察客户端的同步文件结果目录，发现服务端的文件已经同步到这里，则说明 cwRsync 配置及应用成功。

关于HiC Pro 环境配置及使用和hid-core.c的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于.net core 环境配置及运行、2.8-bash环境配置及脚本、87-springboot+shiro+redis的配置及使用、cwRsync 在 windows 环境下的配置及使用等相关内容，可以在本站寻找。

本文标签：