- 发布于2021-10-28 13:47:48赞评论 1浏览 117
-
docker-machine 通过命令的方式端口映射到主机
我只能使用192.168.99.100:3000访问我的应用程序来自docker机器的默认IP。 如何将docker-machine 3000端口转发到主机80端口？ 目前，Docker Machine是在您计算机中VirtualBox下运行的虚拟机，因此要公开您的应用程序端口，您需要将虚拟机端口映射到您的主机端口。 为此，有两个选择，但是在确保停止运行Docker Machine之前，请执行以下操作: docker-machine stop default # see PS below if docker machine isn't default 选项1-使用VirtualBox界面 打开VirtualBox Manager 选择您的Docker Machine VirtualBox镜像(例如:默认) 打开设置->网络->高级->端口转发 添加您的应用名称，所需的主机端口(例如:80)和您的访客端口(例如:3000) 选项2-使用VirtualBox命令行 只需使用您自己的参数运行以下命令: VBoxManage modifyvm "default" --natpf1 "myapp,tcp,,80,,3000" 最后考虑事项 现在，您可以启动运行的Docker Machine: docker-machine start default eval $(docker-machine env default) 然后只需启动应用程序Docker容器并运行http://localhost/对其进行测试。 附言:您的Docker机器名称可能不是默认，在这种情况下，请相应更改名称。赞评论 1浏览 84 - 发布于2021-10-16 14:06:25
25 个常用的 Linux iptables 规则
s -P OUTPUT DROP 阻止某个特定的 IP 地址 #BLOCK_THIS_IP="x.x.x.x" #iptables -A INPUT -s "$BLOCK_THIS_IP" -j DRO 允许全部入站的（incoming）SSH iptables -A INPUT -i eth0 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT 只允许某个特定网络进来的 SSH #iptables -A INPUT -i eth0 -p tcp -s 192.168.200.0/24 --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT 允许入站的（incoming）HTTP iptables -A INPUT -i eth0 -p tcp --dport 80 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -p tcp --sport 80 -m state --state ESTABLISHED -j ACCEPT 多端口（允许进来的 SSH、HTTP 和 HTTPS） iptables -A INPUT -i eth0 -p tcp -m multiport --dports 22,80,443 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -p tcp -m multiport --sports 22,80,443 -m state --state ESTABLISHED -j ACCEPT 允许出站的（outgoing）SSH iptables -A OUTPUT -o eth0 -p tcp --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A INPUT -i eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT 允许出站的（outgoing）SSH，但仅访问某个特定的网络 #iptables -A OUTPUT -o eth0 -p tcp -d 192.168.101.0/24 --dport 22 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A INPUT -i eth0 -p tcp --sport 22 -m state --state ESTABLISHED -j ACCEPT 允许出站的（outgoing） HTTPS iptables -A OUTPUT -o eth0 -p tcp --dport 443 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A INPUT -i eth0 -p tcp --sport 443 -m state --state ESTABLISHED -j ACCEPT 对进来的 HTTPS 流量做负载均衡 #iptables -A PREROUTING -i eth0 -p tcp --dport 443 -m state --state NEW -m nth --counter 0 --every 3 --packet 0 -j DNAT --to-destination 192.168.1.101:443 #iptables -A PREROUTING -i eth0 -p tcp --dport 443 -m state --state NEW -m nth --counter 0 --every 3 --packet 1 -j DNAT --to-destination 192.168.1.102:443 #iptables -A PREROUTING -i eth0 -p tcp --dport 443 -m state --state NEW -m nth --counter 0 --every 3 --packet 2 -j DNAT --to-destination 192.168.1.103:443 从内部向外部 Ping iptables -A OUTPUT -p icmp --icmp-type echo-request -j ACCEPT iptables -A INPUT -p icmp --icmp-type echo-reply -j ACCEPT 从外部向内部 Ping iptables -A INPUT -p icmp --icmp-type echo-request -j ACCEPT iptables -A OUTPUT -p icmp --icmp-type echo-reply -j ACCEPT 允许环回（loopback）访问 iptables -A INPUT -i lo -j ACCEPT iptables -A OUTPUT -o lo -j ACCEPT 允许 packets 从内网访问外网 if eth1 is connected to external network (internet) if eth0 is connected to internal network (192.168.1.x) iptables -A FORWARD -i eth0 -o eth1 -j ACCEPT 允许外出的 DNS iptables -A OUTPUT -p udp -o eth0 --dport 53 -j ACCEPT iptables -A INPUT -p udp -i eth0 --sport 53 -j ACCEPT 允许 NIS 连接 rpcinfo -p | grep ypbind ; This port is 853 and 850 #iptables -A INPUT -p tcp --dport 111 -j ACCEPT #iptables -A INPUT -p udp --dport 111 -j ACCEPT #iptables -A INPUT -p tcp --dport 853 -j ACCEPT #iptables -A INPUT -p udp --dport 853 -j ACCEPT #iptables -A INPUT -p tcp --dport 850 -j ACCEPT #iptables -A INPUT -p udp --dport 850 -j ACCEPT 允许某个特定网络 rsync 进入本机 #iptables -A INPUT -i eth0 -p tcp -s 192.168.101.0/24 --dport 873 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 873 -m state --state ESTABLISHED -j ACCEPT 仅允许来自某个特定网络的 MySQL 的链接 #iptables -A INPUT -i eth0 -p tcp -s 192.168.200.0/24 --dport 3306 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 3306 -m state --state ESTABLISHED -j ACCEPT 允许 Sendmail 或 Postfix iptables -A INPUT -i eth0 -p tcp --dport 25 -m state --state NEW,ESTABLISHED -j ACCEPT iptables -A OUTPUT -o eth0 -p tcp --sport 25 -m state --state ESTABLISHED -j ACCEPT 允许 IMAP 和 IMAPS #iptables -A INPUT -i eth0 -p tcp --dport 143 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 143 -m state --state ESTABLISHED -j ACCEPT #iptables -A INPUT -i eth0 -p tcp --dport 993 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 993 -m state --state ESTABLISHED -j ACCEPT 允许 POP3 和 POP3S #iptables -A INPUT -i eth0 -p tcp --dport 110 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 110 -m state --state ESTABLISHED -j ACCEPT #iptables -A INPUT -i eth0 -p tcp --dport 995 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 995 -m state --state ESTABLISHED -j ACCEPT 防止 DoS 攻击 iptables -A INPUT -p tcp --dport 80 -m limit --limit 25/minute --limit-burst 100 -j ACCEPT 设置 422 端口转发到 22 端口 #iptables -t nat -A PREROUTING -p tcp -d 192.168.102.37 --dport 422 -j DNAT --to 192.168.102.37:22 #iptables -A INPUT -i eth0 -p tcp --dport 422 -m state --state NEW,ESTABLISHED -j ACCEPT #iptables -A OUTPUT -o eth0 -p tcp --sport 422 -m state --state ESTABLISHED -j ACCEPT 为丢弃的包做日志（Log） iptables -N LOGGING iptables -A INPUT -j LOGGING iptables -A LOGGING -m limit --limit 2/min -j LOG --log-prefix "IPTables Packet Dropped: " --log-level 7 iptables -A LOGGING -j DROP赞评论浏览 75 - 发布于2021-10-16 13:43:03
异常记录一下
k<xprType,BlockRow,BlockCols,InnerPanel>::Block(XprType&,Eigen::Index)[with XprType = Eigen::Matnx(double,-1,-1);int BlockRows=-1;intBlockCols=1;bool InnerPanel=true;Eigen::Index=long int]:Assertion `(i>=0)&&(((BlockRows==1)&&(BlockCols==XprType::ColsAtCompileTime)&&i<xpr.rows())||((BlockRows==XprType::RowsAtCompileTime)&&(BlockCols==1)&&i<xpr.cols()))` failed . Aborted(core dumped)赞评论浏览 57 - 赞评论浏览 78
- 发布于2021-10-12 21:06:39
linux安装elasticsearch常用的命令
ngodb -g mongodb -p 123456 http.cors.enabled: true http.cors.allow-origin: "*" 在 /etc/sysctl.conf文件最后添加一行 vm.max_map_count=262144 sysctl -p vi /etc/security/limits.conf # elasticsearch config start * soft nofile 65536 * hard nofile 131072 * soft nproc 4096 * hard nproc 4096 # elasticsearch config end赞评论浏览 52 - 发布于2021-10-10 11:02:14
gitlab常用命令收藏大全
n/<branch> develop 本地建立分支并切换到该分支 git checkout -b branch 合并分支到当前分支 git merge branch git rebase branch git branch 查看本地所有分支 git status 查看当前状态 git commit 提交 git branch -a 查看所有的分支 git branch -r 查看本地所有分支 git branch -avv 查看所有分支详情 git commit -am "init" 提交并且加注释 git remote add origin git@192.168.1.119:ndshow git push origin master 将文件给推到服务器上 git remote show origin 显示远程库origin里的资源 git push origin master:develop git push origin master:hb-dev 将本地库与服务器上的库进行关联 git checkout --track origin/dev 切换到远程dev分支 git branch -D master develop 删除本地库develop git checkout -b dev 建立一个新的本地分支dev git merge origin/dev 将分支dev与当前分支进行合并 git checkout dev 切换到本地dev分支 git remote show 查看远程库 git add . git rm 文件名(包括路径) 从git中删除指定文件 git clone git://github.com/schacon/grit.git 从服务器上将代码给拉下来 git config --list 看所有用户 git ls-files 看已经被提交的 git rm [file name] 删除一个文件 git commit -a 提交当前repos的所有的改变 git add [file name] 添加一个文件到git index git commit -v 当你用－v参数的时候可以看commit的差异 git commit -m "This is the message describing the commit" 添加commit信息 git commit -a -a是代表add，把所有的change加到git index里然后再commit git commit -a -v 一般提交命令 git log 看你commit的日志 git diff 查看尚未暂存的更新 git rm a.a 移除文件(从暂存区和工作区中删除) git rm --cached a.a 移除文件(只从暂存区中删除) git commit -m "remove" 移除文件(从Git中删除) git rm -f a.a 强行移除修改后文件(从暂存区和工作区中删除) git diff --cached 或 $ git diff --staged 查看尚未提交的更新 git stash push 将文件给push到一个临时空间中 git stash pop 将文件从临时空间pop下来 git reset --hard HEAD^ #回退到上一个版本 git reset --hard HEAD^^ #回退到上上个版本 git reset --hard HEAD~100 #回退到前100个版本 git reset --hard 1094a #回退到特定版本号的版本 --------------------------------------------------------- git remote add origin git@github.com:username/Hello-World.git git push origin master 将本地项目给提交到服务器中 ----------------------------------------------------------- git pull 本地与服务器端同步 ----------------------------------------------------------------- git push (远程仓库名) (分支名) 将本地分支推送到服务器上去。 git push origin serverfix:awesomebranch ------------------------------------------------------------------ git fetch 相当于是从远程获取最新版本到本地，不会自动merge git commit -a -m "log_message" (-a是提交所有改动，-m是加入log信息) 本地修改同步至服务器端 ： git branch branch_0.1 master 从主分支master创建branch_0.1分支 git branch -m branch_0.1 branch_1.0 将branch_0.1重命名为branch_1.0 git checkout branch_1.0/master 切换到branch_1.0/master分支 du -hs git init //初始化一个git的本地仓库 git add README.md //将我的文件装上武器，准备发射 git commit -m “first commit” //第一次发射，我的README.md 宝贝已经成功进入到本地仓库 git remote add Ceres your_first_git_address //将第一个git address命名为Ceres git push -u Ceres master //注意咯，我要向远端木星发射了，太远了，一定要用push，很费劲的赶脚 //这时，不要动，准备再次将我的README宝贝发射到火星上去， //但是因为我的文件已经存在与本地仓库了，因此我就不需要再多余地commit等， //只需要将另一个远端仓库与本地仓库建立一个连接就可以了 git remote add Mars your_second_git_address //将第二个git address命名为Mars git push -u Mars master //再次发射，目标火星上的master分支 至此，就将一份代码上传到了两个远端仓库，但是注意你仍然时只有一个本地仓库哦 补充： 在用 git push -u Ceres master 时也要注意这里master是你要上传的分支名称，如果你当前所位于的分支不叫master，用这句话上传就会出错赞评论浏览 85 - 发布于2021-10-02 09:55:19
nginx配置之proxy_pass路径加斜杠/以及包含路径的区别
.1:8080规则都有区别。 2.proxy_pass结尾加斜杠/和不加斜杠的有区别 下面四种情况分别用http://192.168.10.1/proxy/test.html 进行访问。 第一种(末尾加斜杠，proxy_pass中不包含路径）： location /proxy/ { proxy_pass http://127.0.0.1:81/; } 结论：会被代理到http://127.0.0.1:81/test.html ; (proxy_pass+请求url匹配的location路径后的内容） 第二种(末尾不加斜杠,proxy_pass不包含路径) location /proxy/ { proxy_pass http://127.0.0.1:81; } 结论：会被代理到http://127.0.0.1:81/proxy/test.html (proxy_pass替换请求url的ip和端口） 第三种(末尾加斜杠,proxy_pass包含路径)： location /proxy/ { proxy_pass http://127.0.0.1:81/abc/; } 结论：会被代理到http://127.0.0.1:81/abc/test.html (proxy_pass+请求url匹配的location路径后的内容） 第四种(末尾不加斜杠,url包含路径)： location /proxy/ { proxy_pass http://127.0.0.1:81/abc; } 结论：会被代理到http://127.0.0.1:81/abctest.html (proxy_pass+请求url匹配的location路径后的内容) 总结: 1.如果proxy_pass后面有斜杠。转发url为proxy_pass+原url匹配的location路径之后的内容。 例:原请求http://192.168.10.1/proxy/test.html， location 为/proxy/ proxy_pass为 http://127.0.0.1:81/abc/ 转发路径:（proxy_pass）http://127.0.0.1:81/abc/加上原请求部分路径test.html,最终路径http://127.0.0.1:81/abc/test.html 2.proxy_pass后面没有斜杠， a.只有当proxy_pass只有IP加端口，无路径时。匹配规则为proxy_pass替换原请求url的ip和端口， 同时保留了location路径。例子为上述的第二种情况。 b.当proxy_pass端口后包含路径时，匹配规则同1.赞评论浏览 70 - 发布于2021-09-29 16:15:28
记录一下java操作mongodb多条件动态分页查询代码
le<Info> infoExample = Example.of(info); infoExample.getMatcher().withIgnorePaths("lastProcessedTime"); Query query = new Query(Criteria.byExample(infoExample)); Criteria criteria = new Criteria(); Criteria nb = new Criteria(); nb.and("type").is(4).and("docChapters").elemMatch(Criteria.where("lastProcessedTime").exists(false)); Criteria ts = new Criteria(); ts.and("type").is(3).and("lastProcessedTime").exists(false).and("content").exists(true); criteria.orOperator(nb,ts); query.addCriteria(criteria); query.with(Sort.by( Sort.Order.desc("createTime") )); query.with(pageRequest); long count = mongoTemplate.count(query, Info.class); Page<Info> page = new PageImpl<>(mongoTemplate.find(query, Info.class), pageRequest, count); List<Info> infos = page.getContent();赞 1评论浏览 87 - 发布于2021-09-27 18:11:32
MongoDB序列化ObjectId成字符串
来防止分布式系统生成id时冲突的问题，保证每台机器生成的识别码不同，进程号保证多线程情况下生成的id不同。 ObjectId在java程序中是对象类型，示例如下： { id: { "time": 1494233455000, "timestamp": 1494233455, "date": 1494233455000, "new": false, "timeSecond": 1494233455, "inc": -125534200, "machine": -1248386109 } } 有时需要将ObjectId的序列化做处理，将ObjectId直接序列化为字符串。 在接口返回数据前统一处理序列化问题。自定义类实现ResponseBodyAdvice接口，重写beforeBodyWrite方法，自定义序列化方法。 package net.pushi.neo4jdata.dataParser.util; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.alibaba.fastjson.serializer.SerializeConfig; import org.bson.types.ObjectId; import org.springframework.core.MethodParameter; import org.springframework.http.MediaType; import org.springframework.http.converter.HttpMessageConverter; import org.springframework.http.server.ServerHttpRequest; import org.springframework.http.server.ServerHttpResponse; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice; @ControllerAdvice public class MyResponseBodyAdvice implements ResponseBodyAdvice<Object> { @Override public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) { return true; } @Override public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) { SerializeConfig config = new SerializeConfig(); //解决mongdb id序列化问题 config.put(ObjectId.class, new ObjectIdJsonSerializer()); return JSONObject.parse(JSON.toJSONString(body, config)); } } 然后实现一个ObjectIdJsonSerializer package net.pushi.neo4jdata.dataParser.util; import com.alibaba.fastjson.serializer.JSONSerializer; import com.alibaba.fastjson.serializer.ObjectSerializer; import com.alibaba.fastjson.serializer.SerializeWriter; import org.bson.types.ObjectId; import java.io.IOException; import java.lang.reflect.Type; public class ObjectIdJsonSerializer implements ObjectSerializer { @Override public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); if (object == null) { serializer.getWriter().writeNull(); return; } out.write("\"" + ((ObjectId) object).toString() + "\""); } } 这样处理后接口返回的id将变成字符串类型。 { "id":"5ae078ada0f091000be702b8" } 对于Date类型的输出默认为时间戳格式，我们可以自定义输出为格式化字符串，这样可以免去在前端格式化处理。需要在MyResponseBodyAdvice 中注册DateJsonSerializer 。 package net.pushi.neo4jdata.dataParser.util; import cn.hutool.core.date.DateUtil; import com.alibaba.fastjson.serializer.JSONSerializer; import com.alibaba.fastjson.serializer.ObjectSerializer; import com.alibaba.fastjson.serializer.SerializeWriter; import java.io.IOException; import java.lang.reflect.Type; import java.util.Date; public class DateJsonSerializer implements ObjectSerializer { @Override public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType) throws IOException { SerializeWriter out = serializer.getWriter(); if (object == null) { serializer.getWriter().writeNull(); return; } out.write("\"" + DateUtil.format(((Date)object),"yyyy-MM-dd: HH:mm:ss") + "\""); } }赞评论浏览 91 - 发布于2021-09-27 16:05:24
Ubuntu18.04 的netplan网络配置
系统中轻松管理和配置网络设置。 它允许您使用 YAML 格式的描述文件来抽像化定义网络接口的相关信息。 Netplan 可以使用 NetworkManager 或 Systemd-networkd 的网络守护程序来做为内核的接口。Netplan 的默认描述文件在 /etc/netplan/*.yaml 里，Netplan 描述文件采用了 YAML 语法。 在 Ubuntu 18.04 中如果再通过原来的 ifupdown 工具包继续在 /etc/network/interfaces 文件里配置管理网络接口是无效的。 Netplan 根据描述文件中定义的内容自动生成其对应的后端网络守护程序所需要的配置信息，后端网络守护程序再根据其配置信息通过Linux 内核管理对应的网络设备。 Systemd-networkd 是一个管理网络设备的系统守护程序, 它能检测并配置网络设备的状态和创建虚拟网络设备。 常见配置项的含义： 1. enp4s0 指定需配置网络接口的名称。 2. dhcp4 是否打开 IPv4 的 dhcp。 3. dhcp6 是否打开 IPv6 的 dhcp。 4. addresses 定义网络接口的静态 IP 地址。 5. gateway4 指定默认网关的 IPv4 地址。 6. nameservers 指定域名服务器的 IP 地址。 Ubuntu 18.04 Server 安装好后，Netplan 的默认描述文件是：/etc/netplan/01-network-manager-all.yaml 修改 Netplan 的描述文件 # Let NetworkManager manage all devices on this system network: version: 2 renderer: NetworkManager ethernets: enp4s0: #配置的网卡名称,使用ifconfig -a查看得到 dhcp4: no #dhcp4关闭 dhcp6: no #dhcp6关闭 addresses: [192.168.3.188/24] #设置本机IP及掩码 gateway4: 192.168.3.1 #设置网关 nameservers: addresses: [114.114.114.114,8.8.8.8] #设置DNS 运行下面的命令使配置生效 $ sudo netplan apply 配置常用命令 ip a #查看网络信息 ifconfig #查看网络信息 netplan apply #应用netplan配置修改 非root用户需要sudo权限 到此Ipv4配置完成赞评论浏览 66 - 发布于2021-09-25 22:39:12
pm2运行命令
me my-api #my-api为PM2进程名称 # pm2 start app.js -i 0 #根据CPU核数启动进程个数 # pm2 start app.js --watch #实时监控app.js的方式启动，当app.js文件有变动时，pm2会自动reload 2. 查看进程 # pm2 list # pm2 show 0 或者 # pm2 info 0 #查看进程详细信息，0为PM2进程id 3. 监控 # pm2 monit 4. 停止 # pm2 stop all #停止PM2列表中所有的进程 # pm2 stop 0 #停止PM2列表中进程为0的进程 5. 重载 # pm2 reload all #重载PM2列表中所有的进程 # pm2 reload 0 #重载PM2列表中进程为0的进程 6. 重启 # pm2 restart all #重启PM2列表中所有的进程 # pm2 restart 0 #重启PM2列表中进程为0的进程 7. 删除PM2进程 # pm2 delete 0 #删除PM2列表中进程为0的进程 # pm2 delete all #删除PM2列表中所有的进程 8. 日志操作 # pm2 logs [--raw] #Display all processes logs in streaming # pm2 flush #Empty all log file # pm2 reloadLogs #Reload all logs 9. 升级PM2 # npm install pm2@lastest -g #安装最新的PM2版本 # pm2 updatePM2 #升级pm2 10. 更多命令参数请查看帮助 # pm2 --help 二、PM2目录结构 默认的目录是：当前用于的家目录下的.pm2目录（此目录可以自定义，请参考：五、自定义启动文件），详细信息如下： $HOME/.pm2 #will contain all PM2 related files $HOME/.pm2/logs #will contain all applications logs $HOME/.pm2/pids #will contain all applications pids $HOME/.pm2/pm2.log #PM2 logs $HOME/.pm2/pm2.pid #PM2 pid $HOME/.pm2/rpc.sock #Socket file for remote commands $HOME/.pm2/pub.sock #Socket file for publishable events $HOME/.pm2/conf.js #PM2 Configuration 三、自定义启动文件 创建一个test.json的示例文件，格式如下： { "apps": { "name": "test", "cwd": "/data/wwwroot/nodejs", "script": "./test.sh", "exec_interpreter": "bash", "min_uptime": "60s", "max_restarts": 30, "exec_mode" : "cluster_mode", "error_file" : "./test-err.log", "out_file": "./test-out.log", "pid_file": "./test.pid" "watch": false } } 说明： apps：json结构，apps是一个数组，每一个数组成员就是对应一个pm2中运行的应用 name：应用程序的名称 cwd：应用程序所在的目录 script：应用程序的脚本路径 exec_interpreter：应用程序的脚本类型，这里使用的shell，默认是nodejs min_uptime：最小运行时间，这里设置的是60s即如果应用程序在60s内退出，pm2会认为程序异常退出，此时触发重启max_restarts设置数量 max_restarts：设置应用程序异常退出重启的次数，默认15次（从0开始计数） exec_mode：应用程序启动模式，这里设置的是cluster_mode（集群），默认是fork error_file：自定义应用程序的错误日志文件 out_file：自定义应用程序日志文件 pid_file：自定义应用程序的pid文件 watch：是否启用监控模式，默认是false。如果设置成true，当应用程序变动时，pm2会自动重载。这里也可以设置你要监控的文件。 详细参数列表：见附件八 四、实例 已上面的test.json为例 # cat > /data/wwwroot/nodejs/test.sh << EOF #!/bin/bash while : do echo "Test" >> 1.log sleep 5 done EOF pm2 启动命令 pm2 start npm --name "biemo-bbs" -- run start 如下图 链接赞评论浏览 91 
发布于2021-09-23 09:50:47关于mysql安装过程中命令mysqld --initialize --console出错的解答
Data # 允许最大连接数 max_connections=200 # 允许连接失败的次数。 max_connect_errors=10 # 服务端使用的字符集默认为utf8mb4 character-set-server=utf8mb4 # 创建新表时将使用的默认存储引擎 default-storage-engine=INNODB # 默认使用“mysql_native_password”插件认证 #mysql_native_password default_authentication_plugin=mysql_native_password [mysql] # 设置mysql客户端默认字符集 default-character-set=utf8mb4 [client] # 设置mysql客户端连接服务端时默认使用的端口 port=3306 default-character-set=utf8mb4 输入命令mysqld --initialize --console时会弹出如下错误 这里只需要更改前面步骤中插入的文件my.ini里面MySQL的安装目录和MySQL的数据库存放目录，改成自己的MySQL存放路径即可赞 1评论 2浏览 138- 发布于2021-09-22 23:42:09
java模糊查询——MongoDB
ompatible Regular Expression) 作为正则表达式语言。 当要实现MongoDB的document中某字段内容模糊查询时，可以在数组字段中使用正则表达式来查找内容 示例代码： /** * @Description: fuzzy，设置模糊查询条件 * @param map: * @return: org.bson.Document * @Author: hsy * @Date: 2020/12/11 */ public Document fuzzy(Map<String, Object> map){ List<Map<String, Object>> fuzzys = new ArrayList<>(); Document document = new Document(); if (map.containsKey("filter") && null != map.get("filter") && !"".equals(map.get("filter")) && map.get("filter")instanceof Map){ Map<String,Object> filter = (Map<String, Object>) map.get("filter"); for (Map.Entry<String, Object> entry:filter.entrySet()){ Map<String,Object> fuzzy = new HashMap<>(); Map<String,Object> regex = new HashMap<>(); regex.put("$regex",entry.getValue()); fuzzy.put(entry.getKey(),regex); fuzzys.add(fuzzy); } if (null != fuzzys && fuzzys.size()>0){ document = new Document("$and", fuzzys); } } return document; } /** * @Description: fuzzyQuery，模糊查询 * @param map: * @return: java.util.List<java.util.Map<java.lang.String,java.lang.Object>> * @Author: hsy * @Date: 2020/12/11 */ @Override public List<Map<String, Object>> fuzzyQuery(Map<String, Object> map) { MongoCursor<Document> cursor = getDBCollection(map.get("collectionName").toString()).find(fuzzy(map)).iterator(); List<Map<String, Object>> mapList = new ArrayList<>(); while (cursor.hasNext()){ Document document = cursor.next(); mapList.add(document); } return mapList; }赞 2评论浏览 131 - 发布于2021-09-22 23:39:39
聚合查询及相关语法——Neo4j
n: findList，多标签查询指定关系节点 * @param map: * @return: java.util.Map * @Author: hsy * @Date: 2020/12/12 */ public Map findList(Map<String,Object> map){ String cypher; //Neo4j执行语句 Map<String, Object> relation; //返回结果集 List<String> types = new ArrayList<>(); //关系类型集(type) if (map.containsKey("event_type") && null != map.get("event_type") && !"".equals(map.get("event_type"))){ Map<String, Object> filter = new HashMap<>(); filter.put("event_type",map.get("event_type")); List<Map<String, Object>> relationTypes = mongoDBService.findRelationTypes(filter); for (Map<String, Object> relationType:relationTypes){ types.add(relationType.get("type").toString()); } } types = addMark(types); if (map.containsKey("labels") && null != map.get("labels") && !"".equals(map.get("labels")) && map.get("labels") instanceof List){ //有节点标签条件(List) List<String> labels = (List<String>) map.get("labels"); labels = addMark(labels); if (types.size()>0){ //有关系类别条件 cypher = "match p=(n)-[r]-(m) where any(label in labels(n) where label in "+labels+") and type(r) in "+types+" return p"; //cypher = "match p=(n)-[r]-(m) where any(label in labels(n) where label in "+labels+") and type(r) in "+types+" return n,r,m"; relation = DatabaseUtil.deepQuery(cypher); }else { //无关系类别条件 cypher = "match p=(n)-[r]-(m) where any(label in labels(n) where label in "+labels+") return p"; relation = DatabaseUtil.deepQuery(cypher); } if (!relation.containsKey("nodes") || null == relation.get("nodes") || "".equals(relation.get("nodes")) || (relation.get("nodes") instanceof Set && !(0<((Set) relation.get("nodes")).size()))){ //三元组查询结果为空，则返回节点 cypher = "match (n) where any(label in labels(n) where label in "+labels+") return n"; List<Map<String, Object>> nodes = DatabaseUtil.nodeToMap(cypher); relation.put("nodes",nodes); relation.put("relationships",new ArrayList<Map<String, Object>>()); } }else if (map.containsKey("labels") && null != map.get("labels") && !"".equals(map.get("labels")) && map.get("labels") instanceof String){ //有节点标签条件(String) if (types.size()>0){ //有关系类别条件 cypher = "match p=(n)-[r]-(m) where any(label in labels(n) where label = \'"+map.get("labels")+"\') and type(r) in "+types+" return p"; relation = DatabaseUtil.deepQuery(cypher); }else { //无关系类别条件 cypher = "match p=(n)-[r]-(m) where any(label in labels(n) where label = \'"+map.get("labels")+"\') return p"; relation = DatabaseUtil.deepQuery(cypher); } if (!relation.containsKey("nodes") || null == relation.get("nodes") || "".equals(relation.get("nodes")) || (relation.get("nodes") instanceof Set && !(0<((Set) relation.get("nodes")).size()))){ //三元组查询结果为空，则返回节点 cypher = "match (n) where any(label in labels(n) where label = \'"+map.get("labels")+"\') return n"; List<Map<String, Object>> nodes = DatabaseUtil.nodeToMap(cypher); relation.put("nodes",nodes); relation.put("relationships",new ArrayList<Map<String, Object>>()); } }else { //无节点标签条件 if (types.size()>0){ //有关系类别条件 cypher = "match p=(n)-[r]-(m) where type(r) in "+types+" return p"; relation = DatabaseUtil.deepQuery(cypher); }else { //无关系类别条件 cypher = "match p=(n)-[r]-(m) return r limit 500"; relation = DatabaseUtil.deepQuery(cypher); } if (!relation.containsKey("nodes") || null == relation.get("nodes") || "".equals(relation.get("nodes")) || (relation.get("nodes") instanceof Set && !(0<((Set) relation.get("nodes")).size()))){ //三元组查询结果为空，则返回节点 cypher = "match (n) return n limit 50"; List<Map<String, Object>> nodes = DatabaseUtil.nodeToMap(cypher); relation.put("nodes",nodes); relation.put("relationships",new ArrayList<Map<String, Object>>()); } } return relation; } /** * @Description: deepQuery，深度查询返回三元组方法 * @param string: 查询语句 * @return: java.util.Map<java.lang.String,java.lang.Object> * @Author: hsy * @Date: 2020/12/12 */ public static Map<String, Object> deepQuery(String string){ Set<Map<String, Object>> nodeList = new HashSet<>(); Set<Map<String, Object>> relationshipList = new HashSet<>(); Map<String, Object> relation = new HashMap<>(); Result result = DatabaseUtil.neo4jExecute(string); Iterable<Map<String, Object>> it = result.queryResults(); for (Map<String, Object> data : it){ for (Map.Entry<String, Object> entry : data.entrySet()){ Object object = entry.getValue(); if (object instanceof InternalPath){ InternalPath IP = (InternalPath) object; //节点 Iterable<Node> nodes = IP.nodes(); for (Node node : nodes){ Map<String, Object> asMap = node.asMap(); nodeList.add(setProperty(setBasePropertyNode(node),asMap)); } //关系 Iterable<Relationship> relationships = IP.relationships(); for (Relationship relationship : relationships){ Map<String, Object> asMap = relationship.asMap(); relationshipList.add(setProperty(setBasePropertyRelation(relationship),asMap)); } }else if (object instanceof NodeModel){ //节点 NodeModel nodeModel = (NodeModel) object; nodeList.add(setPropertyNodeModel(nodeModel)); }else if (object instanceof RelationshipModel){ //关系 RelationshipModel relationshipModel = (RelationshipModel) object; relationshipList.add(setPropertyRelationshipModel(relationshipModel)); } } } relation.put("nodes",nodeList); relation.put("relationships",relationshipList); return relation; } /** * @Description: relationToMap，关系模型===》Map * @param string: * @return: java.util.List<java.util.Map<java.lang.String,java.lang.Object>> * @Author: hsy * @Date: 2020/12/12 */ public static List<Map<String, Object>> relationToMap(String string){ Set<Map<String, Object>> relationships = new HashSet<>(); Result resultRelations = DatabaseUtil.neo4jExecute(string); ArrayList<LinkedHashMap<String, ArrayList<RelationshipModel>>> listRelations = (ArrayList)resultRelations.queryResults(); for (LinkedHashMap<String, ArrayList<RelationshipModel>> linkedHashMap:listRelations){ for (ArrayList<RelationshipModel> value:linkedHashMap.values()){ for (RelationshipModel relationshipModel:value){ relationships.add(DatabaseUtil.setPropertyRelationshipModel(relationshipModel)); } } } return new ArrayList<>(relationships); } /** * @Description: nodeToMap，节点模型===》Map * @param string: * @return: java.util.List<java.util.Map<java.lang.String,java.lang.Object>> * @Author: hsy * @Date: 2020/12/12 */ public static List<Map<String, Object>> nodeToMap(String string){ Set<Map<String, Object>> nodes = new HashSet<>(); Result resultNode = DatabaseUtil.neo4jExecute(string); ArrayList<LinkedHashMap<String, NodeModel>> listNodes = (ArrayList)resultNode.queryResults(); for (LinkedHashMap<String,NodeModel> linkedHashMap:listNodes){ for (NodeModel value:linkedHashMap.values()){ nodes.add(DatabaseUtil.setPropertyNodeModel(value)); } } return new ArrayList<>(nodes); } 其他相关操作语法： //创建节点 create (n:`地图`{name_chs:"中东",名称:"中东",经度:"48.00",纬度:"12.00"}) //模糊查询 MATCH (n:`舰艇`) where n.别名=~'.*埃塞克斯号.*' RETURN n //查询与节点name为长沙有关的节点和关系 MATCH p=(n:`地图`{名称:'长沙市'})-[*1..1]-() return p limit 99 //创建关系(需要APOC包) UNWIND {list} as row MATCH (startNode) WHERE startNode._id = row.start WITH row,startNode MATCH (endNode) WHERE endNode._id = row.end CALL apoc.create.relationship(startNode, row.type, row.props, endNode) yield rel RETURN count(*) //根据name创建关系 UNWIND {list} as row MATCH (startNode) WHERE startNode.name = row.startNodeName WITH row,startNode MATCH (endNode) WHERE endNode.name = row.endNodeName Merge (startNode)-[rel:`TargetRelation`]->(endNode) SET rel += row.props //根据id创建关系 UNWIND {rows} as row MATCH (startNode) WHERE ID(startNode) = row.startNodeId WITH row,startNode MATCH (endNode) WHERE ID(endNode) = row.endNodeId CREATE (startNode)-[rel:`TargetRelation`]->(endNode) SET rel += row.props //创建指定关系 match(a),(b) where id(a)={0} and id(b)={1} create c= (a)-[r:TargetRelation{number:{2},startTarget:{3},relationType:{4},endTarget:{5},createTime:{6}}]->(b) return c //节点多标签查询 match p=(n)-[r]-(m) where any(label in labels(n) where label in ['X1体系','X2体系']) return n //关系多类型查询 match p=(n)-[r]-(m) where type(r) in ['指挥关系','备份关系'] return p //节点标签，关系类型联合查询 match p=(n)-[r]-(m) where any(label in labels(n) where label in ['X1体系']) and type(r) in ['指挥关系','上报关系'] return p 社区版备份或者换库 //数据备份到文件 neo4j-admin dump --database=graph.db --to=D:/Neo4j/neo4j-community-3.5.7/data/dump/graph.dump //备份的数据文件导入 bin/neo4j-admin load --from=D:/Neo4j/neo4j-community-3.5.7/data/dump/graph.dump --database=graph.db --force赞评论浏览 94 - 发布于2021-09-22 23:37:01
java字符串与数组相互转换
tring splitStr){ if (map.containsKey(key) && null != map.get(key) && !"".equals(map.get(key))){ String[] arrayStr = map.get(key).toString().split(splitStr);//字符串转字符数组 List<String> strings = Arrays.asList(arrayStr); map.put(key,strings); } } //字符串分割转数组 public static Map<String,Object> string2Array(Map<String,Object> map ,String key,String splitStr){ String string = map.get(key)!=null?map.get(key).toString():""; if(string!=null&&string.trim().length()>0){ String[] strArr = string.split(splitStr); map.put(key,strArr); } return map; } 数组转字符串： 使用StringUtils的join(); 使用ArrayUtils的toString();赞评论浏览 85 - 发布于2021-09-22 23:33:38
汉字转拼音(多音字处理)——Java
rt java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType; import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat; import net.sourceforge.pinyin4j.format.HanyuPinyinToneType; import net.sourceforge.pinyin4j.format.HanyuPinyinVCharType; import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * @Program: * @ClassName: PinyinUtil * @Description: 汉字转拼音 * @Author: hsy * @CreateDate: 2020/12/7 **/ public class PinyinUtil { private static Map<String, List<String>> pinyinMap = new HashMap<String, List<String>>(); /** * @Description: convertInitialToUpperCase，将某个字符串的首字母大写 * @param str: 汉字字符串 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String convertInitialToUpperCase(String str){ if(str==null){ return null; } StringBuffer sb = new StringBuffer(); char[] arr = str.toCharArray(); for(int i=0;i<arr.length;i++){ char ch = arr[i]; if(i==0){ sb.append(String.valueOf(ch).toUpperCase()); }else{ sb.append(ch); } } return sb.toString(); } /** * @Description: convertChineseToPinyin，汉字转拼音，多音字自定义配置 * @param chinese: 汉字字符串 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String convertChineseToPinyin(String chinese){ String path = System.getProperty("user.dir")+"/duoyinzi_dic.txt"; // System.out.println("多音字字典路径=====》"+path); initPinyin(path); StringBuffer pinyin = new StringBuffer(); HanyuPinyinOutputFormat defaultFormat = new HanyuPinyinOutputFormat(); defaultFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE); defaultFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE); char[] arr = chinese.toCharArray(); for (int i = 0; i < arr.length; i++){ char ch = arr[i]; if (ch > 128){ //非ASCII码 // 取得当前汉字的所有全拼 try { String[] results = PinyinHelper.toHanyuPinyinStringArray(ch, defaultFormat); if (results == null){ //非中文 return ""; }else { int len = results.length; if (len == 1){ //不是多音字 // pinyin.append(results[0]); String py = results[0]; if (py.contains("u:")){ //过滤 u: py = py.replace("u:", "v"); // System.out.println("filter u:"+py); } pinyin.append(convertInitialToUpperCase(py)); //拼音首字母大写 }else if (results[0].equals(results[1])){ //非多音字 有多个音，取第一个 // pinyin.append(results[0]); pinyin.append(convertInitialToUpperCase(results[0])); }else { //多音字 // System.out.println("多音字："+ch); int length = chinese.length(); boolean flag = false; String s = null; List<String> keyList =null; for (int x = 0; x < len; x++){ String py = results[x]; if (py.contains("u:")){ //过滤 u: py = py.replace("u:", "v"); // System.out.println("filter u:"+py); } keyList = pinyinMap.get(py); if (i + 3 <= length){ //后向匹配2个汉字 s = chinese.substring(i, i + 3); if (keyList != null && (keyList.contains(s))){ // System.out.println("last 2 > " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); flag = true; break; } } if (i + 2 <= length){ //后向匹配 1个汉字 s = chinese.substring(i, i + 2); if (keyList != null && (keyList.contains(s))){ // System.out.println("last 1 > " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); flag = true; break; } } if ((i - 2 >= 0) && (i+1<=length)){ // 前向匹配2个汉字 s = chinese.substring(i - 2, i+1); if (keyList != null && (keyList.contains(s))){ // System.out.println("before 2 < " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); flag = true; break; } } if ((i - 1 >= 0) && (i+1<=length)){ // 前向匹配1个汉字 s = chinese.substring(i - 1, i+1); if (keyList != null && (keyList.contains(s))){ // System.out.println("before 1 < " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); flag = true; break; } } if ((i - 1 >= 0) && (i+2<=length)){ //前向1个，后向1个 s = chinese.substring(i - 1, i+2); if (keyList != null && (keyList.contains(s))){ // System.out.println("before last 1 <> " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); flag = true; break; } } } if (!flag){ //都没有找到，匹配默认的读音 s = String.valueOf(ch); for (int x = 0; x < len; x++){ String py = results[x]; if (py.contains("u:")){ py = py.replace("u:", "v"); // System.out.println("filter u:"); } keyList = pinyinMap.get(py); if (keyList != null && (keyList.contains(s))){ // System.out.println("default = " + py); // pinyin.append(results[x]); pinyin.append(convertInitialToUpperCase(py)); break; } } } } } }catch (BadHanyuPinyinOutputFormatCombination e){ e.printStackTrace(); } }else { pinyin.append(arr[i]); } } return pinyin.toString(); } /** * @Description: initPinyin，多音字配置 * @param fileName: * @return: void * @Author: hsy * @Date: 2020/12/7 */ public static void initPinyin(String fileName) { BufferedReader br = null; try { // 读取多音字的全部拼音表; InputStream file = new FileInputStream(fileName); // InputStream file = PinyinHelper.class.getResourceAsStream(fileName); br = new BufferedReader(new InputStreamReader(file)); String s; while ((s = br.readLine()) != null) { if (s != null) { String[] arr = s.split("#"); String pinyin = arr[0]; String chinese = arr[1]; if(chinese!=null){ String[] strs = chinese.split(" "); List<String> list = Arrays.asList(strs); pinyinMap.put(pinyin, list); } } } } catch (IOException e) { e.printStackTrace(); }finally{ try { br.close(); } catch (IOException e) { e.printStackTrace(); } } } /** * @Description: getPinyin，汉字转拼音 * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinyin(String paramString) { return getPinyinZh_CN(convertStringByChinese(paramString)); } /** * @Description: getPinyinToUpperCase，汉字转拼音（大写） * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinyinToUpperCase(String paramString) { return getPinyinZh_CN(convertStringByChinese(paramString)).toUpperCase(); } /** * @Description: getPinyinToLowerCase，汉字转拼音（小写） * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinyinToLowerCase(String paramString) { return getPinyinZh_CN(convertStringByChinese(paramString)).toLowerCase(); } /** * @Description: getPinyinFirstToUpperCase，汉字转拼音首字母大写 * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinyinFirstToUpperCase(String paramString) { return getPinyin(paramString); } private static HanyuPinyinOutputFormat getDefaultFormat() { HanyuPinyinOutputFormat localHanyuPinyinOutputFormat = new HanyuPinyinOutputFormat(); localHanyuPinyinOutputFormat.setCaseType(HanyuPinyinCaseType.LOWERCASE); localHanyuPinyinOutputFormat.setToneType(HanyuPinyinToneType.WITHOUT_TONE); localHanyuPinyinOutputFormat.setVCharType(HanyuPinyinVCharType.WITH_U_AND_COLON); return localHanyuPinyinOutputFormat; } private static Set<String> convertStringByChinese(String paramString) { char[] arrayOfChar1 = paramString.toCharArray(); if ((paramString != null) && (!paramString.trim().equalsIgnoreCase(""))) { char[] arrayOfChar2 = paramString.toCharArray(); String[][] arrayOfString = new String[paramString.length()][]; for (int i = 0; i < arrayOfChar2.length; i++) { char c = arrayOfChar2[i]; if ((String.valueOf(c).matches("[\\u4E00-\\u9FA5]+")) || (String.valueOf(c).matches("[\\u3007]"))) { try { arrayOfString[i] = PinyinHelper.toHanyuPinyinStringArray(arrayOfChar1[i], getDefaultFormat()); } catch (BadHanyuPinyinOutputFormatCombination localBadHanyuPinyinOutputFormatCombination) { localBadHanyuPinyinOutputFormatCombination.printStackTrace(); } } else { arrayOfString[i] = new String[] { String.valueOf(arrayOfChar2[i]) }; } } String[] arrayOfString1 = exchange(arrayOfString); HashSet localHashSet = new HashSet(); for (int j = 0; j < arrayOfString1.length; j++) { localHashSet.add(arrayOfString1[j]); } return localHashSet; } return null; } private static String[] exchange(String[][] paramArrayOfString) { String[][] arrayOfString = doExchange(paramArrayOfString); return arrayOfString[0]; } private static String[][] doExchange(String[][] paramArrayOfString) { int i = paramArrayOfString.length; if (i >= 2) { int j = paramArrayOfString[0].length; int k = paramArrayOfString[1].length; int m = j * k; String[] arrayOfString = new String[m]; int n = 0; for (int i1 = 0; i1 < j; i1++) { for (int i2 = 0; i2 < k; i2++) { arrayOfString[n] = (capitalize(paramArrayOfString[0][i1]) + capitalize(paramArrayOfString[1][i2])); n++; } } String[][] arrayOfString1 = new String[i - 1][]; for (int i2 = 2; i2 < i; i2++) { arrayOfString1[(i2 - 1)] = paramArrayOfString[i2]; } arrayOfString1[0] = arrayOfString; return doExchange(arrayOfString1); } return paramArrayOfString; } private static String capitalize(String paramString) { char[] arrayOfChar = paramString.toCharArray(); if ((arrayOfChar != null) && (arrayOfChar.length > 0) && (arrayOfChar[0] >= 'a') && (arrayOfChar[0] <= 'z')) { arrayOfChar[0] = ((char) (arrayOfChar[0] - ' ')); } return new String(arrayOfChar); } private static String getPinyinZh_CN(Set<String> paramSet) { StringBuilder localStringBuilder = new StringBuilder(); int i = 0; Iterator localIterator = paramSet.iterator(); while (localIterator.hasNext()) { String str = (String) localIterator.next(); if (i == paramSet.size() - 1) { localStringBuilder.append(str); } else { localStringBuilder.append(str + ","); } i++; } return localStringBuilder.toString(); } /** * @Description: getPinYinHeadChar，汉字转拼音，只返回首字母 * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinYinHeadChar(String paramString) { StringBuffer localStringBuffer = new StringBuffer(); if ((paramString != null) && (!paramString.trim().equalsIgnoreCase(""))) { for (int i = 0; i < paramString.length(); i++) { char c = paramString.charAt(i); String[] arrayOfString = PinyinHelper.toHanyuPinyinStringArray(c); if (arrayOfString != null) { localStringBuffer.append(arrayOfString[0].charAt(0)); } else { localStringBuffer.append(c); } } } return localStringBuffer.toString(); } public static String strFilter(String paramString) throws PatternSyntaxException { String str = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？\"]"; Pattern localPattern = Pattern.compile(str); Matcher localMatcher = localPattern.matcher(paramString); return localMatcher.replaceAll("").trim(); } /** * @Description: getPinYinHeadCharFilter，汉字转拼音，只返回首字母并过滤特殊字符 * @param paramString: 要转拼音的汉字 * @return: java.lang.String * @Author: hsy * @Date: 2020/12/7 */ public static String getPinYinHeadCharFilter(String paramString) { return strFilter(getPinYinHeadChar(paramString)); } public static void main(String[] paramArrayOfString) { String path = System.getProperty("user.dir")+"/duoyinzi_dic.txt"; System.out.println("路径=====》"+path); initPinyin(path); String pinyin = convertChineseToPinyin("捋捋关系"); System.out.println("pinyin=====>"+pinyin); Logger localLogger = LoggerFactory.getLogger(PinyinUtil.class); // String str = "〇的输￥￥#s，ldsa"; String str = "捋捋关系"; localLogger.info("小写输出：" + getPinyinToLowerCase(str)); localLogger.info("大写输出：" + getPinyinToUpperCase(str)); localLogger.info("首字母大写输出：" + getPinyinFirstToUpperCase(str)); localLogger.info("返回中文的首字母输出：" + getPinYinHeadChar(str)); localLogger.info("返回中文的首字母并过滤特殊字符输出：" + getPinYinHeadCharFilter(str)); } }赞评论浏览 77 - 发布于2021-09-22 23:26:53
java项目启动脚本源码收藏
_PATH=$PWD APP_LOG_PATH=$APP_PATH APP_LOG_NAME=$PROJECT_NAME.log XMS=512m XMX=1024m #使用说明，用来提示输入参数 usage() { echo "Usage: sh ${PROJECT_NAME}-server.sh [start|stop|restart|status]" exit 1 } #检查程序是否在运行 is_exist(){ pid=`ps -ef|grep $APP_NAME|grep -v grep|awk '{print $2}' ` #如果不存在返回1，存在返回0 if [ -z "${pid}" ]; then return 1 else return 0 fi } #启动方法 start(){ is_exist if [ $? -eq "0" ]; then echo "${APP_NAME} is already running. pid=${pid} ." else nohup java -jar $APP_PATH/$APP_NAME -Xms${XMS} -Xmx${XMX} -XX:PermSize=64m -XX:MaxPermSize=128m -Dfile.encoding=utf-8 > $APP_LOG_PATH/$APP_LOG_NAME 2>&1 & echo "${APP_NAME} start success" fi } #停止方法 stop(){ is_exist if [ $? -eq "0" ]; then kill -9 $pid echo "${APP_NAME} is stop" else echo "${APP_NAME} is not running" fi } #输出运行状态 status(){ is_exist if [ $? -eq "0" ]; then echo "${APP_NAME} is running. Pid is ${pid}" else echo "${APP_NAME} is NOT running." fi } #重启 restart(){ stop start } #根据输入参数，选择执行对应方法，不输入则执行使用说明 case "$1" in "start") start ;; "stop") stop ;; "status") status ;; "restart") restart ;; *) usage ;; esac赞评论浏览 84 - 发布于2021-09-22 23:13:37
neo4j常用命令收藏
{list} as row MATCH (startNode) WHERE startNode.name = row.startNodeName WITH row,startNode MATCH (endNode) WHERE endNode.name = row.endNodeName Merge (startNode)-[rel:`TargetRelation`]->(endNode) SET rel += row.props //根据id创建关系 UNWIND {rows} as row MATCH (startNode) WHERE ID(startNode) = row.startNodeId WITH row,startNode MATCH (endNode) WHERE ID(endNode) = row.endNodeId CREATE (startNode)-[rel:`TargetRelation`]->(endNode) SET rel += row.props //创建指定关系 match(a),(b) where id(a)={0} and id(b)={1} create c= (a)-[r:TargetRelation{number:{2},startTarget:{3},relationType:{4},endTarget:{5},createTime:{6}}]->(b) return c //创建节点 create (n:`地图`{name_chs:"中东",名称:"中东",经度:"48.00",纬度:"12.00"}) //模糊查询 MATCH (n:`舰艇`) where n.别名=~'.*埃塞克斯号.*' RETURN n 社区版备份或者换库 1、数据备份到文件 neo4j-admin dump --database=graph.db --to=D:/Neo4j/neo4j-community-3.5.7/data/dump/graph.dump 2、备份的数据文件导入 bin/neo4j-admin load --from=D:/Neo4j/neo4j-community-3.5.7/data/dump/graph.dump --database=graph.db --force赞评论浏览 74 - 发布于2021-09-22 23:08:45
settings.xml
*</mirrorOf> <url>http://maven.aliyun.com/nexus/content/groups/public/</url> </mirror> </mirrors> <profiles> <profile> <id>nexus</id> <repositories> <repository> <id>central</id> <url>http://central</url> <releases> <enabled>true</enabled> <updatePolicy>always</updatePolicy> </releases> <snapshots> <enabled>true</enabled> <updatePolicy>always</updatePolicy> </snapshots> </repository> </repositories> <pluginRepositories> <pluginRepository> <id>central</id> <url>http://central</url> <releases><enabled>true</enabled></releases> <snapshots><enabled>true</enabled></snapshots> </pluginRepository> </pluginRepositories> <properties> <downloadSources>true</downloadSources> <downloadJavadocs>true</downloadJavadocs> </properties> </profile> </profiles> <activeProfiles> <activeProfile>nexus</activeProfile> </activeProfiles> </settings>赞评论浏览 71 - 发布于2021-09-22 23:02:01
vsftpd配置过程记录
问 local_enable=YES //设定本地用户可以访问。注：如使用虚拟宿主用户，在该项目设定为NO的情况下所有虚拟用户将无法访问 chroot_list_enable=YES //使用户不能离开主目录 chroot_list_file=/etc/vsftpd/chroot_list ascii_upload_enable=YES ascii_download_enable=YES //设定支持ASCII模式的上传和下载功能 pam_service_name=vsftpd //PAM认证文件名。PAM将根据/etc/pam.d/vsftpd进行认证 //已下三个请在配置文件中手动添加 guest_enable=YES //设定启用虚拟用户功能 guest_username=ftp //指定虚拟用户的宿主用户，CentOS中已经有内置的ftp用户了 user_config_dir=/etc/vsftpd/vuser_conf //设定虚拟用户个人vsftp的CentOS FTP服务文件存放路径。存放虚拟用户个性的CentOS FTP服务文件(配置文件名=虚拟用户名 2.创建用户密码文件/etc/vsftpd/vuser_passwd.txt ，注意奇行是用户名，偶行是密码 vi vuser_passwd.txt admin passwd 3.生成虚拟用户认证的db文件 db_load -T -t hash -f /etc/vsftpd/vuser_passwd.txt /etc/vsftpd/vuser_passwd.db ls 查看有没有vuser.passwd.db生成 4.编辑认证文件/etc/pam.d/vsftpd 把前面的注释去掉，然后加上以下几条 注：db=/etc/vsftpd/vuser_passwd 中的vuser_passwd 是你生成的虚拟用户的db文件 查看系统版本号： getconf LONG_BIT 系统为32位： auth required pam_userdb.so db=/etc/vsftpd/vuser_passwd account required pam_userdb.so db=/etc/vsftpd/vuser_passwd 系统为64位： auth required /lib64/security/pam_userdb.so db=/etc/vsftpd/vuser_passwd account required /lib64/security/pam_userdb.so db=/etc/vsftpd/vuser_passwd 5.创建虚拟用户配置文件 mkdir /etc/vsftpd/vuser_conf/ vi /etc/vsftpd/vuser_conf/admin //文件名等于vuser_passwd.txt里面的账户名，否则下面设置无效 6.设置用户配置文件内容 local_root=/storage/ftp //虚拟用户根目录,根据实际情况修改 该目录必须要有读写权限 write_enable=YES //可写 anon_umask=022 //掩码 anon_world_readable_only=NO anon_upload_enable=YES anon_mkdir_write_enable=YES anon_other_write_enable=YES 7.设置文件夹权限 chmod -R 777 /storage 8.设置Selinux setsebool -P ftp_home_dir=1 //设置ftp可以使用home目录 setsebool -P allow_ftpd_full_access=1 //设置ftp用户可以有所有权限 9.启动vsftpd服务 service vsftpd start赞评论浏览 66 - 赞 1评论浏览 97
发布于2021-09-21 13:35:13《收藏》封装了element ui 的el-cascader动态懒加载数据支持回显组件
:props="casProps" style="width:500px;margin-right: 20px;" clearable @change="handleChange"> </el-cascader> </template> <script> import { getCateByPidAndSite } from '@/api/goods/category' export default { name: 'ProjectCascader', data() { return { casProps: { value: 'categoryId', label: 'categoryName', checkStrictly: true, lazy: true, // 此处必须为true lazyLoad: (node, resolve) => { this.getChildProject(node, resolve) } } } }, props: ['categoryId', 'site'], methods: { handleChange(value) { // 将当前选中节点数据和当前路径数组返回给父组件 // this.$emit('getData', value) // 获取当前选中节点 const checkNode = this.$refs['cascader'].getCheckedNodes() // 将当前选中节点数据和当前路径数组返回给父组件 this.$emit('getData', checkNode[0].data, value) }, // 懒加载树数据 getChildProject(node, resolve) { const params = { parentId: node.root ? '0' : node.data.categoryId, site: this.site } let childProjects = []; getCateByPidAndSite(params).then(res => { if (res.code !== '0') { this.$message.error('获取项目数据失败') } else { childProjects = res.data.map(item => { return { cateId: item.id, categoryId: item.categoryId, categoryName: item.categoryName, leaf: item.leafCategory == '1' ? true : false } }) // 获取数据后调用resolve将子项数据渲染至视图 resolve(childProjects) } }).catch(error => { console.log('获取数据异常', error) // 此处调用resolve 防止接口数据异常时级联选择器一直处于加载状态 resolve(childProjects) }) } } } </script> <style> .el-cascader-panel{ height:300px; } </style>赞 1评论 1浏览 155-
springboot自带json工具 jackson 工具类封装
xml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.DeserializationFeature; import com.fasterxml.jackson.databind.JavaType; import com.fasterxml.jackson.databind.ObjectMapper; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; /** * Jackson 工具类 * <p>Title: MapperUtils</p> * <p>Description: </p> * * @author Lusifer * @version 1.0.0 * @date 2018/3/4 21:50 */ public class MapperUtils { private final static ObjectMapper objectMapper = new ObjectMapper(); public static ObjectMapper getInstance() { return objectMapper; } /** * 转换为 JSON 字符串 * * @param obj * @return * @throws Exception */ public static String obj2json(Object obj) throws Exception { return objectMapper.writeValueAsString(obj); } /** * 转换为 JSON 字符串，忽略空值 * * @param obj * @return * @throws Exception */ public static String obj2jsonIgnoreNull(Object obj) throws Exception { ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); return mapper.writeValueAsString(obj); } /** * 转换为 JavaBean * * @param jsonString * @param clazz * @return * @throws Exception */ public static <T> T json2pojo(String jsonString, Class<T> clazz) throws Exception { objectMapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true); return objectMapper.readValue(jsonString, clazz); } /** * 字符串转换为 Map<String, Object> * * @param jsonString * @return * @throws Exception */ public static <T> Map<String, Object> json2map(String jsonString) throws Exception { ObjectMapper mapper = new ObjectMapper(); mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); return mapper.readValue(jsonString, Map.class); } /** * 字符串转换为 Map<String, T> */ public static <T> Map<String, T> json2map(String jsonString, Class<T> clazz) throws Exception { Map<String, Map<String, Object>> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, T>>() { }); Map<String, T> result = new HashMap<String, T>(); for (Map.Entry<String, Map<String, Object>> entry : map.entrySet()) { result.put(entry.getKey(), map2pojo(entry.getValue(), clazz)); } return result; } /** * 深度转换 JSON 成 Map * * @param json * @return */ public static Map<String, Object> json2mapDeeply(String json) throws Exception { return json2MapRecursion(json, objectMapper); } /** * 把 JSON 解析成 List，如果 List 内部的元素存在 jsonString，继续解析 * * @param json * @param mapper 解析工具 * @return * @throws Exception */ private static List<Object> json2ListRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null) { return null; } List<Object> list = mapper.readValue(json, List.class); for (Object obj : list) { if (obj != null && obj instanceof String) { String str = (String) obj; if (str.startsWith("[")) { obj = json2ListRecursion(str, mapper); } else if (obj.toString().startsWith("{")) { obj = json2MapRecursion(str, mapper); } } } return list; } /** * 把 JSON 解析成 Map，如果 Map 内部的 Value 存在 jsonString，继续解析 * * @param json * @param mapper * @return * @throws Exception */ private static Map<String, Object> json2MapRecursion(String json, ObjectMapper mapper) throws Exception { if (json == null) { return null; } Map<String, Object> map = mapper.readValue(json, Map.class); for (Map.Entry<String, Object> entry : map.entrySet()) { Object obj = entry.getValue(); if (obj != null && obj instanceof String) { String str = ((String) obj); if (str.startsWith("[")) { List<?> list = json2ListRecursion(str, mapper); map.put(entry.getKey(), list); } else if (str.startsWith("{")) { Map<String, Object> mapRecursion = json2MapRecursion(str, mapper); map.put(entry.getKey(), mapRecursion); } } } return map; } /** * 将 JSON 数组转换为集合 * * @param jsonArrayStr * @param clazz * @return * @throws Exception */ public static <T> List<T> json2list(String jsonArrayStr, Class<T> clazz) throws Exception { JavaType javaType = getCollectionType(ArrayList.class, clazz); List<T> list = (List<T>) objectMapper.readValue(jsonArrayStr, javaType); return list; } /** * 获取泛型的 Collection Type * * @param collectionClass 泛型的Collection * @param elementClasses 元素类 * @return JavaType Java类型 * @since 1.0 */ public static JavaType getCollectionType(Class<?> collectionClass, Class<?>... elementClasses) { return objectMapper.getTypeFactory().constructParametricType(collectionClass, elementClasses); } /** * 将 Map 转换为 JavaBean * * @param map * @param clazz * @return */ public static <T> T map2pojo(Map map, Class<T> clazz) { return objectMapper.convertValue(map, clazz); } /** * 将 Map 转换为 JSON * * @param map * @return */ public static String mapToJson(Map map) { try { return objectMapper.writeValueAsString(map); } catch (Exception e) { e.printStackTrace(); } return ""; } /** * 将 JSON 对象转换为 JavaBean * * @param obj * @param clazz * @return */ public static <T> T obj2pojo(Object obj, Class<T> clazz) { return objectMapper.convertValue(obj, clazz); } }赞评论浏览 171 -
Biemo-cloud 3.0 开发中...
|—— bbs-vue ├── app-biz |—— biemo-bbs |—— biemo-bbs-api |—— biemo-bbs-app ├── biemo-auth |—— biemo-auth-api └── biemo-auth-app ├── biemo-biz ├── modular-dict ├── modular-file └── modular-log ├── biemo-gateway ├── biemo-kernel ├── common-lib ├── kernel-core ├── kernel-jwt ├── kernel-logger ├── kernel-scanner └── kernel-validator ├── biemo-microservices ├── biemo-cloud-monitor ├── biemo-cloud-register └── biemo-cloud-server ├── biemo-system ├── biemo-system-api └── biemo-system-app └── sql 界面预览 界面地址赞 1评论浏览 296
