win 10 家庭版没有本地安全策略的添加方法及所在位置路径

 windows  win 10 家庭版没有本地安全策略的添加方法及所在位置路径已关闭评论
7月 162022
 

win 10 家庭版默认是没有本地安全策略的， 但可以通过下面方式添加。

  1. 新建一个bat文件，内容如下：

@echo off

pushd “%~dp0″

dir /b C:\Windows\servicing\Packages\Microsoft-Windows-GroupPolicy-ClientExtensions-Package~3*.mum >List.txt

dir /b C:\Windows\servicing\Packages\Microsoft-Windows-GroupPolicy-ClientTools-Package~3*.mum >>List.txt

for /f %%i in (‘findstr /i . List.txt 2^>nul’) do dism /online /norestart /add-package:”C:\Windows\servicing\Packages\%%i”

pause

2. 以管理员身份运行，运行过程中可能会看到它反复安装好几次，没关系，等提示“按任意键继续”后按键结束， 安装完毕。

 

“本地安全策略”位置在哪里？

打开“控制面板”， 将“查看方式”调整为“大图标”，找到“管理工具”并点击， 就能看到“”“本地安全策略”了

DONE！

 

XCODE中不同添加方式下获取文件/图片的路径的方法(Bundle.main.path,Bundle)

 swift, xcode  XCODE中不同添加方式下获取文件/图片的路径的方法(Bundle.main.path,Bundle)已关闭评论
12月 202019
 

XCODE中获取添加的文件的路径的3个方法，以下以显示图片测试获取图片路径的方法：

 

测试的UIViewController的demo源码(TestImageViewController.swift)，注释中详细描述3个不同添加文件方式下获取路径的方法，GOOD LUCK！

 

import AVFoundation

 

class TestImageViewController: UIViewController {

    

    lazy var imageView: UIImageView = {

       

        let imageView = UIImageView(frame: CGRect(x: 0, y: 0, width: UIScreen.main.bounds.width, height: UIScreen.main.bounds.height))

        //方法1:  选择Targets中项目 –> build Phases中 –> copy Bundle Resources点击下面的+ 直接添加的alalay.jpg

        //let testImage = UIImage(contentsOfFile: Bundle.main.path(forResource: “alalay”, ofType: “jpg”)!)

        

        //方法2:  新建目录任意命名如imgs,将测试图片alalay.jpg文件拖入imgs目录后，将imgs目录名称修改为imgs.bundle,将这个imgs.bundle拖入xcode项目

        //let testImage = UIImage(contentsOfFile: Bundle.main.path(forResource: “imgs”, ofType: “bundle”)! + “/” + “alalay.jpg”)

        

        //方法3:   将alalay.jpg图片放在Assets.xcassets中

        let testImage = UIImage(named:“alalay.jpg”)!

        

        imageView.image = testImage

        imageView.contentMode = .scaleAspectFit

        return imageView

    }()

    

    override func viewDidLoad() {

        super.viewDidLoad()

        view.addSubview(imageView)

    }

}

java文件读取的路径问题解惑和最佳实践,避免FileNotFoundException

 java  java文件读取的路径问题解惑和最佳实践,避免FileNotFoundException已关闭评论
1月 042018
 

   网上找到的一篇讲解java 读取文件路径比较清楚的文章， 分享下：http://blog.csdn.net/aitangyong/article/details/36471881 

     使用java读取jar或war下的配置文件，是开发者经常需要处理的事情，大家是不是经常遇到FileNotFoundException呢?java读取文件的方式也有很多，比如new File()，Class.getResource()，ClassLoader.getResource()，这些方式的差别是什么呢？开源框架struts2的ClassLoaderUtils和Spring提供ClassPathResource，都提供了对资源读取进行封装的工具类，你是否了解他们的实现原理呢？本文结合网上的一些博客和自己的理解，和大家一起讨论下java的文件读取问题。

1.使用new File()的问题

File是java.io包下的基础类，代表硬盘上的一个文件或者目录，我们可以使用绝对路径来构造，也可以使用相对路径来构造。

工程在硬盘和eclipse的目录结构如下：






在eclipse中运行上面的程序，发现2种方式都是能够正确读取文件的，不会抛FileNotFoundException。

使用绝对路径，虽然定位很清晰，但是不灵活。比如你将上面的工程放到D盘下，就必须要修改绝对路径路径，这显然很不方便。使用相对路径则跟工程所在的硬盘路径无关，直接导入eclipse中运行，就能够正确读取文件内容。而且实际情况是，很多时候我们并不知道文件的绝对路径，这会因为部署环境的不同而不同。比如将制作好的war放到tomcat或jboss容器下运行，很显然绝对路径是不同的，而我们的代码事先并不知道。

那么使用相对路径呢？很遗憾，也同样存在很多问题。File是java.io包的基础类，java.io 包中的类总是根据当前用户目录来分析相对路径名。也就是说以下2种方式是等价的，

[java] view plain copy

  1. File file1 = new File(“demo.txt”);  
  2.           
  3. String asbPath = System.getProperty(“user.dir”) + “/demo.txt”;  
  4. File file2 = new File(asbPath);  

也就是说相对路径是否好使，取决于user.dir的值。系统属性 user.dir是JVM启动的时候设置的，通常是 Java 虚拟机的调用目录，即执行java命令所在的目录。

对于tomcat/jboss容器，user.dir是%home/bin%/目录，因为这个目录就是我们启动web容器的地方。也就是说，user.dir也是可变的，不固定的。显然使用这种方式跟绝对路径没有什么本质差别，都是不推荐的。顺便提一下，我们在eclipse中运行程序的时候，eclipse会将user.dir的值设置为工程的根目录，在我们的例子中,user.dir是c:/workspace/path_project/

可以得出结论：使用java.io.File读取文件，无论是相对路径，还是绝对路径都不是好的做法，能不使用就不要使用。

2.使用Class.getResource()或ClassLoader.getResource()

这2个方法用来读取jar包中或者classpath下的资源文件。以下方式都能够正确的定位文件
[java] view plain copy

  1. TestClass.class.getResource(“test.txt”);  
  2. TestClass.class.getResource(“/net/aty/test.txt”);  
  3.           
  4. TestClass.class.getClassLoader().getResource(“net/aty/test.txt”);  

Class.getResource()有2种方式，绝对路径和相对路径。绝对路径以/开头，从classpath或jar包根目录下开始搜索；

相对路径是相对当前class所在的目录，允许使用..或.来定位文件。ClassLoader.getResource()只能使用绝对路径，而且不用以/开头。

这两种方式读取资源文件，不会依赖于user.dir，也不会依赖于具体部署的环境，是推荐的做法。

3.使用Class或ClassLoader.getResource()的相对路径和绝对路径问题

无论是相对路径还是绝对路径，都是推荐的做法。考虑下这样的场景，如果a.jar中的类，需要读取b.jar中的资源文件怎么实现呢?
用相对路径和绝对路径都可以吗？
制作b.jar，并将它加入到eclipse工程的build path下，如下图

[java] view plain copy

  1. package net.aty;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.InputStreamReader;  
  5. import java.net.URL;  
  6.   
  7. public class TestClass  
  8. {  
  9.   
  10.     public static void main(String[] args) throws Exception  
  11.     {  
  12.         // 使用相对路径,正常读取b.jar中的文件  
  13.         showContent(TestClass.class.getResource(“b.txt”));  
  14.   
  15.         // 使用相对路径,正常读取b.jar中的文件  
  16.         showContent(TestClass.class.getResource(“test/c.txt”));  
  17.   
  18.         // 使用绝对对路径,正常读取b.jar中的文件  
  19.         showContent(TestClass.class.getResource(“/net/a.txt”));  
  20.   
  21.         // 使用绝对对路径,正常读取b.jar中的文件  
  22.         showContent(TestClass.class.getClassLoader().getResource(“net/aty/test/c.txt”));  
  23.   
  24.         // 使用相对路径,正常读取本jar中的same.txt  
  25.         showContent(TestClass.class.getResource(“../same.txt”));  
  26.           
  27.         // 错误  
  28.         showContent(TestClass.class.getResource(“../a.txt”));  
  29.     }  
  30.   
  31.     public static void showContent(URL url) throws Exception  
  32.     {  
  33.         BufferedReader br = new BufferedReader(new InputStreamReader(  
  34.                 url.openStream()));  
  35.   
  36.         StringBuilder contentHolder = new StringBuilder();  
  37.   
  38.         String lineContent = null;  
  39.   
  40.         while ((lineContent = br.readLine()) != null)  
  41.         {  
  42.             contentHolder.append(lineContent);  
  43.         }  
  44.   
  45.         br.close();  
  46.   
  47.         System.out.println(“content=” + contentHolder);  
  48.   
  49.     }  
  50. }  

可以得出结论：

使用相对路径或绝对路径都能读取本jar或其他jar中的资源文件。但区别是，读取本jar包中的文件支持..这种写法，但是不能通过..读取其他jar下的文件。

4.spring框架的ClassPathResource实现

[java] view plain copy

  1. /** 
  2.      * This implementation opens an InputStream for the given class path resource. 
  3.      * @see java.lang.ClassLoader#getResourceAsStream(String) 
  4.      * @see java.lang.Class#getResourceAsStream(String) 
  5.      */  
  6.     public InputStream getInputStream() throws IOException {  
  7.         InputStream is;  
  8.         if (this.clazz != null) {  
  9.             is = this.clazz.getResourceAsStream(this.path);  
  10.         }  
  11.         else {  
  12.             is = this.classLoader.getResourceAsStream(this.path);  
  13.         }  
  14.         if (is == null) {  
  15.             throw new FileNotFoundException(getDescription() + ” cannot be opened because it does not exist”);  
  16.         }  
  17.         return is;  
  18.     }  

可以看出spring提供的ClassPathResource，底层使用的就是Class.getResource或ClassLoader.getResource()。spring提供的读取文件API功能，自然是与JDK一致。

[java] view plain copy

  1. public class TestFile  
  2. {  
  3.     public static void main(String[] args) throws Exception  
  4.     {  
  5.         File absoluteFile = new File(“c:/workspace/path_project/demo.txt”);  
  6.         File relativeFile = new File(“demo.txt”);  
  7.   
  8.         showFileContent(absoluteFile);  
  9.   
  10.         showFileContent(relativeFile);  
  11.   
  12.     }  
  13.   
  14.     public static void showFileContent(File file) throws Exception  
  15.     {  
  16.         BufferedReader br = new BufferedReader(new FileReader(file));  
  17.   
  18.         StringBuilder contentHolder = new StringBuilder();  
  19.   
  20.         String lineContent = null;  
  21.   
  22.         while ((lineContent = br.readLine()) != null)  
  23.         {  
  24.             contentHolder.append(lineContent);  
  25.         }  
  26.   
  27.         br.close();  
  28.   
  29.         System.out.println(“content=” + contentHolder);  
  30.   
  31.     }  
  32.   
  33. }  

工程在硬盘和eclipse的目录结构如下：





在eclipse中运行上面的程序，发现2种方式都是能够正确读取文件的，不会抛FileNotFoundException。

使用绝对路径，虽然定位很清晰，但是不灵活。比如你将上面的工程放到D盘下，就必须要修改绝对路径路径，这显然很不方便。使用相对路径则跟工程所在的硬盘路径无关，直接导入eclipse中运行，就能够正确读取文件内容。而且实际情况是，很多时候我们并不知道文件的绝对路径，这会因为部署环境的不同而不同。比如将制作好的war放到tomcat或jboss容器下运行，很显然绝对路径是不同的，而我们的代码事先并不知道。

那么使用相对路径呢？很遗憾，也同样存在很多问题。File是java.io包的基础类，java.io 包中的类总是根据当前用户目录来分析相对路径名。也就是说以下2种方式是等价的，

[java] view plain copy

  1. File file1 = new File(“demo.txt”);  
  2.           
  3. String asbPath = System.getProperty(“user.dir”) + “/demo.txt”;  
  4. File file2 = new File(asbPath);  

也就是说相对路径是否好使，取决于user.dir的值。系统属性 user.dir是JVM启动的时候设置的，通常是 Java 虚拟机的调用目录，即执行java命令所在的目录。

对于tomcat/jboss容器，user.dir是%home/bin%/目录，因为这个目录就是我们启动web容器的地方。也就是说，user.dir也是可变的，不固定的。显然使用这种方式跟绝对路径没有什么本质差别，都是不推荐的。顺便提一下，我们在eclipse中运行程序的时候，eclipse会将user.dir的值设置为工程的根目录，在我们的例子中,user.dir是c:/workspace/path_project/

可以得出结论：使用java.io.File读取文件，无论是相对路径，还是绝对路径都不是好的做法，能不使用就不要使用。

2.使用Class.getResource()或ClassLoader.getResource()

这2个方法用来读取jar包中或者classpath下的资源文件。以下方式都能够正确的定位文件
[java] view plain copy

  1. TestClass.class.getResource(“test.txt”);  
  2. TestClass.class.getResource(“/net/aty/test.txt”);  
  3.           
  4. TestClass.class.getClassLoader().getResource(“net/aty/test.txt”);  

Class.getResource()有2种方式，绝对路径和相对路径。绝对路径以/开头，从classpath或jar包根目录下开始搜索；

相对路径是相对当前class所在的目录，允许使用..或.来定位文件。ClassLoader.getResource()只能使用绝对路径，而且不用以/开头。

这两种方式读取资源文件，不会依赖于user.dir，也不会依赖于具体部署的环境，是推荐的做法。

3.使用Class或ClassLoader.getResource()的相对路径和绝对路径问题

无论是相对路径还是绝对路径，都是推荐的做法。考虑下这样的场景，如果a.jar中的类，需要读取b.jar中的资源文件怎么实现呢?
用相对路径和绝对路径都可以吗？
制作b.jar，并将它加入到eclipse工程的build path下，如下图

[java] view plain copy

  1. package net.aty;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.InputStreamReader;  
  5. import java.net.URL;  
  6.   
  7. public class TestClass  
  8. {  
  9.   
  10.     public static void main(String[] args) throws Exception  
  11.     {  
  12.         // 使用相对路径,正常读取b.jar中的文件  
  13.         showContent(TestClass.class.getResource(“b.txt”));  
  14.   
  15.         // 使用相对路径,正常读取b.jar中的文件  
  16.         showContent(TestClass.class.getResource(“test/c.txt”));  
  17.   
  18.         // 使用绝对对路径,正常读取b.jar中的文件  
  19.         showContent(TestClass.class.getResource(“/net/a.txt”));  
  20.   
  21.         // 使用绝对对路径,正常读取b.jar中的文件  
  22.         showContent(TestClass.class.getClassLoader().getResource(“net/aty/test/c.txt”));  
  23.   
  24.         // 使用相对路径,正常读取本jar中的same.txt  
  25.         showContent(TestClass.class.getResource(“../same.txt”));  
  26.           
  27.         // 错误  
  28.         showContent(TestClass.class.getResource(“../a.txt”));  
  29.     }  
  30.   
  31.     public static void showContent(URL url) throws Exception  
  32.     {  
  33.         BufferedReader br = new BufferedReader(new InputStreamReader(  
  34.                 url.openStream()));  
  35.   
  36.         StringBuilder contentHolder = new StringBuilder();  
  37.   
  38.         String lineContent = null;  
  39.   
  40.         while ((lineContent = br.readLine()) != null)  
  41.         {  
  42.             contentHolder.append(lineContent);  
  43.         }  
  44.   
  45.         br.close();  
  46.   
  47.         System.out.println(“content=” + contentHolder);  
  48.   
  49.     }  
  50. }  

可以得出结论：

使用相对路径或绝对路径都能读取本jar或其他jar中的资源文件。但区别是，读取本jar包中的文件支持..这种写法，但是不能通过..读取其他jar下的文件。

4.spring框架的ClassPathResource实现

[java] view plain copy

  1. /** 
  2.      * This implementation opens an InputStream for the given class path resource. 
  3.      * @see java.lang.ClassLoader#getResourceAsStream(String) 
  4.      * @see java.lang.Class#getResourceAsStream(String) 
  5.      */  
  6.     public InputStream getInputStream() throws IOException {  
  7.         InputStream is;  
  8.         if (this.clazz != null) {  
  9.             is = this.clazz.getResourceAsStream(this.path);  
  10.         }  
  11.         else {  
  12.             is = this.classLoader.getResourceAsStream(this.path);  
  13.         }  
  14.         if (is == null) {  
  15.             throw new FileNotFoundException(getDescription() + ” cannot be opened because it does not exist”);  
  16.         }  
  17.         return is;  
  18.     }  

可以看出spring提供的ClassPathResource，底层使用的就是Class.getResource或ClassLoader.getResource()。spring提供的读取文件API功能，自然是与JDK一致。

supervisor 默认配置文件路径

 supervisord  supervisor 默认配置文件路径已关闭评论
12月 292017
 

运行supervisord服务的时候，需要指定supervisor配置文件，如果没有显示指定，默认在以下目录查找：
$CWD/supervisord.conf
$CWD/etc/supervisord.conf
/etc/supervisord.conf
/etc/supervisor/supervisord.conf (since Supervisor 3.3.0)
../etc/supervisord.conf (Relative to the executable)
../supervisord.conf (Relative to the executable)

$CWD表示运行supervisord程序的目录。
可以通过运行echo_supervisord_conf程序生成supervisor的初始化配置文件，如下所示：
mkdir /etc/supervisor
echo_supervisord_conf > /etc/supervisor/supervisord.conf

XX.class.getResource()与XXX.class.getClassLoader().getResource(url)研究

 java  XX.class.getResource()与XXX.class.getClassLoader().getResource(url)研究已关闭评论
4月 062014
 

挺不错的介绍class.getResource()与.class.getClassLoader().getResource的文章，学习了.

获取文件路径是很常用的操作，但在这之前你必须对url的相对路径和绝对路径有所了解。

如果我想获取工程的路径，或者说我想获取工程里某个文件应该怎么办呢？

方法就是用class获取Resource。

比如我们写个类叫XXX.java

获取资源文件就可以使用2个方法，分别是

XXX.class.getResource()与XXX.class.getClassLoader().getResource(url)。

关于怎么获取和这两者的区别，做个试验就很清楚了。

现在给出我的文件结构：

src(源文件夹)
  |_org
      |_path
      |    |_child
      |    |     |FileTwo.txt
      |    |
      |    |PathUtil.java
      |    |FileOne.txt
      |
      |_path2
            |fileThree.txt

如图：

废话不多说，看试验吧：

PathUtil 

package org.path;

import java.io.File;

/**
 * XXX.class.getResource()与XXX.class.getClassLoader().getResource(url)研究
 * @author lushuaiyin
 *
 */
public class PathUtil {

	public static void main(String[] args) {
		String path1=PathUtil.class.getResource("").getPath();
		System.out.println("path1:"+path1);

		String path2=PathUtil.class.getResource("/").getPath();
		System.out.println("path2:"+path2);

		String path3=PathUtil.class.getClassLoader().getResource("").getPath();
		System.out.println("path3:"+path3);

//		String path4=PathUtil.class.getClassLoader().getResource("/").getPath();
//		System.out.println("path4:"+path4);//空指针报错


		System.out.println("-------------------------------------------");

		//知道XXX.class.getResource(url)和XXX.class.getClassLoader().getResource(url)的区别后，
		//下面开始使用这2个方法找到我们想要的文件

		//一：找和本class同包下的文件，例如FileOne.txt
		//方式1(从本类路径开始找)
		File fileOne1=new File(PathUtil.class.getResource("FileOne.txt").getFile());
		System.out.println("fileOne1:"+PathUtil.class.getResource("FileOne.txt").getFile());
		//方式2(从根路径开始找)
		File fileOne2=new File(PathUtil.class.getClassLoader().getResource("org/path/FileOne.txt").getFile());
		System.out.println("fileOne2:"+PathUtil.class.getClassLoader().getResource("org/path/FileOne.txt").getFile());


		System.out.println("");

		//二：找和本class同包下的子目录下的文件，例如FileTwo.txt
		//方式1(从本类路径开始找)
		File fileTwo1=new File(PathUtil.class.getResource("child/FileTwo.txt").getFile());
		System.out.println("fileTwo1:"+PathUtil.class.getResource("child/FileTwo.txt").getFile());
		//方式2(从根路径开始找)
		File fileTwo2=new File(PathUtil.class.getClassLoader().getResource("org/path/child/FileTwo.txt").getFile());
		System.out.println("fileTwo2:"+PathUtil.class.getClassLoader().getResource("org/path/child/FileTwo.txt").getFile());


        System.out.println("");

		//三：找和本class父目录同包下的文件，例如FileThree.txt
		//方式1(从本类路径开始找)
		File fileThree1=new File(PathUtil.class.getResource("../path2/FileThree.txt").getFile());
		System.out.println("fileThree1:"+PathUtil.class.getResource("../path2/FileThree.txt").getFile());
		//方式2(从根路径开始找)
		File fileThree2=new File(PathUtil.class.getClassLoader().getResource("org/path2/FileThree.txt").getFile());
		System.out.println("fileThree2:"+PathUtil.class.getClassLoader().getResource("org/path2/FileThree.txt").getFile());


	}


	/*
	 首先给出文件路径结构：

	 src(源文件夹)
	   |_org
	       |_path
	       |    |_child
	       |    |     |FileTwo.txt
	       |    |
	       |    |PathUtil.java
	       |    |FileOne.txt
	       |
	       |_path2
	             |fileThree.txt

	 XXX.class.getResource(url)
	    这个是从当前类XXX的路径开始找。

	 XXX.class.getClassLoader().getResource(url)
	 这个是从根目录开始找。
	 所以PathUtil.class.getClassLoader().getResource("/").getPath()会报错。


	 打印：

path1:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path/
path2:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/
path3:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/
-------------------------------------------
fileOne1:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path/FileOne.txt
fileOne2:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path/FileOne.txt

fileTwo1:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path/child/FileTwo.txt
fileTwo2:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path/child/FileTwo.txt

fileThree1:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path2/FileThree.txt
fileThree2:/D:/ChinaDevelopmentBankJBPM/workSpace/frame/webapp/WEB-INF/classes/org/path2/FileThree.txt


	 */
}

上面的试验清楚明了，唯一要注意的地方就是：

PathUtil.class.getResource(“”).getPath()  得到本类路径

PathUtil.class.getResource(“/”).getPath() 得到根路径 

PathUtil.class.getClassLoader().getResource(“”).getPath()  得到根路径 

PathUtil.class.getClassLoader().getResource(“/”).getPath()  空指针报错，因为它从根路径找文件，你给的url不是文件的url

转自：http://m.blog.csdn.net/blog/lushuaiyin/8603081