一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Programming Language

转载Java NIO中的Files类的使用

Java NIO中的Files类（java.nio.file.Files）提供了多种操作文件系统中文件的方法。 Files.exists() Files.exits()方法用来检查给定的Path在文件系统中是否存在。 在文件系统中创建一个原本不存在的Payh是可行的。例如，你想新建一个目录，那么闲创建对应的Path实例，然后创建目录。 由于Path实例可能指向文件系统中的不存在的路径，所以需要用Files.exists()来确认。 下面是一个使用Files.exists()的示例：

1
2
3
4
5
Path path = Paths.get("data/logging.properties");
 
boolean pathExists =
        Files.exists(path,
            new LinkOption[]{ LinkOption.NOFOLLOW_LINKS});

  这个示例中，我们首先创建了一个Path对象，然后利用Files.exists()来检查这个路径是否真实存在。 注意Files.exists()的的第二个参数。他是一个数组，这个参数直接影响到Files.exists()如何确定一个路径是否存在。在本例中，这个数组内包含了LinkOptions.NOFOLLOW_LINKS，表示检测时不包含符号链接文件。 Files.createDirectory() Files.createDirectory()会创建Path表示的路径，下面是一个示例：

1
2
3
4
5
6
7
8
9
10
Path path = Paths.get("data/subdir");
 
try {
    Path newDir = Files.createDirectory(path);
} catch(FileAlreadyExistsException e){
    // the directory already exists.
} catch (IOException e) {
    //something else went wrong
    e.printStackTrace();
}

  第一行创建了一个Path实例，表示需要创建的目录。接着用try-catch把Files.createDirectory()的调用捕获住。如果创建成功，那么返回值就是新创建的路径。 如果目录已经存在了，那么会抛出java.nio.file.FileAlreadyExistException异常。如果出现其他问题，会抛出一个IOException。比如说，要创建的目录的父目录不存在，那么就会抛出IOException。父目录指的是你要创建的目录所在的位置。也就是新创建的目录的上一级父目录。 Files.copy() Files.copy()方法可以吧一个文件从一个地址复制到另一个位置。例如：

1
2
3
4
5
6
7
8
9
10
11
Path sourcePath      = Paths.get("data/logging.properties");
Path destinationPath = Paths.get("data/logging-copy.properties");
 
try {
    Files.copy(sourcePath, destinationPath);
} catch(FileAlreadyExistsException e) {
    //destination file already exists
} catch (IOException e) {
    //something else went wrong
    e.printStackTrace();
}

  这个例子当中，首先创建了原文件和目标文件的Path实例。然后把它们作为参数，传递给Files.copy(),接着就会进行文件拷贝。 如果目标文件已经存在，就会抛出java.nio.file.FileAlreadyExistsException异常。类似的吐过中间出错了，也会抛出IOException。 覆盖已经存在的文件(Overwriting Existing Files) copy操作可以强制覆盖已经存在的目标文件。下面是具体的示例：

1
2
3
4
5
6
7
8
9
10
11
12
Path sourcePath      = Paths.get("data/logging.properties");
Path destinationPath = Paths.get("data/logging-copy.properties");
 
try {
    Files.copy(sourcePath, destinationPath,
            StandardCopyOption.REPLACE_EXISTING);
} catch(FileAlreadyExistsException e) {
    //destination file already exists
} catch (IOException e) {
    //something else went wrong
    e.printStackTrace();
}

  注意copy方法的第三个参数，这个参数决定了是否可以覆盖文件。 Files.move() Java NIO的Files类也包含了移动的文件的接口。移动文件和重命名是一样的，但是还会改变文件的目录位置。java.io.File类中的renameTo()方法与之功能是一样的。

1
2
3
4
5
6
7
8
9
10
Path sourcePath      = Paths.get("data/logging-copy.properties");
Path destinationPath = Paths.get("data/subdir/logging-moved.properties");
 
try {
    Files.move(sourcePath, destinationPath,
            StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
    //moving file failed.
    e.printStackTrace();
}

  首先创建源路径和目标路径的，原路径指的是需要移动的文件的初始路径，目标路径是指需要移动到的位置。 这里move的第三个参数也允许我们覆盖已有的文件。 Files.delete() Files.delete()方法可以删除一个文件或目录：

1
2
3
4
5
6
7
8
Path path = Paths.get("data/subdir/logging-moved.properties");
 
try {
    Files.delete(path);
} catch (IOException e) {
    //deleting file failed
    e.printStackTrace();
}

  首先创建需要删除的文件的path对象。接着就可以调用delete了。 Files.walkFileTree() Files.walkFileTree()方法具有递归遍历目录的功能。walkFileTree接受一个Path和FileVisitor作为参数。Path对象是需要遍历的目录，FileVistor则会在每次遍历中被调用。 下面先来看一下FileVisitor这个接口的定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface FileVisitor {
 
    public FileVisitResult preVisitDirectory(
        Path dir, BasicFileAttributes attrs) throws IOException;
 
    public FileVisitResult visitFile(
        Path file, BasicFileAttributes attrs) throws IOException;
 
    public FileVisitResult visitFileFailed(
        Path file, IOException exc) throws IOException;
 
    public FileVisitResult postVisitDirectory(
        Path dir, IOException exc) throws IOException {
 
}

  FileVisitor需要调用方自行实现，然后作为参数传入walkFileTree().FileVisitor的每个方法会在遍历过程中被调用多次。如果不需要处理每个方法，那么可以继承他的默认实现类SimpleFileVisitor，它将所有的接口做了空实现。 下面看一个walkFileTree()的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Files.walkFileTree(path, new FileVisitor<Path>() {
  @Override
  public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
    System.out.println("pre visit dir:" + dir);
    return FileVisitResult.CONTINUE;
  }
 
  @Override
  public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
    System.out.println("visit file: " + file);
    return FileVisitResult.CONTINUE;
  }
 
  @Override
  public FileVisitResult visitFileFailed(Path file, IOException exc) throws IOException {
    System.out.println("visit file failed: " + file);
    return FileVisitResult.CONTINUE;
  }
 
  @Override
  public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
    System.out.println("post visit directory: " + dir);
    return FileVisitResult.CONTINUE;
  }
});

  FileVisitor的方法会在不同时机被调用： preVisitDirectory()在访问目录前被调用。postVisitDirectory()在访问后调用。 visitFile()会在整个遍历过程中的每次访问文件都被调用。他不是针对目录的，而是针对文件的。visitFileFailed()调用则是在文件访问失败的时候。例如，当缺少合适的权限或者其他错误。 上述四个方法都返回一个FileVisitResult枚举对象。具体的可选枚举项包括： CONTINUE TERMINATE SKIP_SIBLINGS SKIP_SUBTREE 返回这个枚举值可以让调用方决定文件遍历是否需要继续。 CONTINE表示文件遍历和正常情况下一样继续。 TERMINATE表示文件访问需要终止。 SKIP_SIBLINGS表示文件访问继续，但是不需要访问其他同级文件或目录。 SKIP_SUBTREE表示继续访问，但是不需要访问该目录下的子目录。这个枚举值仅在preVisitDirectory()中返回才有效。如果在另外几个方法中返回，那么会被理解为CONTINE。 Searching For Files 下面看一个例子，我们通过walkFileTree()来寻找一个README.txt文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Path rootPath = Paths.get("data");
String fileToFind = File.separator + "README.txt";
 
try {
  Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
 
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
      String fileString = file.toAbsolutePath().toString();
      //System.out.println("pathString = " + fileString);
 
      if(fileString.endsWith(fileToFind)){
        System.out.println("file found at path: " + file.toAbsolutePath());
        return FileVisitResult.TERMINATE;
      }
      return FileVisitResult.CONTINUE;
    }
  });
} catch(IOException e){
    e.printStackTrace();
}

  Deleting Directies Recursively Files.walkFileTree()也可以用来删除一个目录以及内部的所有文件和子目。Files.delete()只用用于删除一个空目录。我们通过遍历目录，然后在visitFile()接口中三次所有文件，最后在postVisitDirectory()内删除目录本身。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
Path rootPath = Paths.get("data/to-delete");
 
try {
  Files.walkFileTree(rootPath, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
      System.out.println("delete file: " + file.toString());
      Files.delete(file);
      return FileVisitResult.CONTINUE;
    }
 
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
      Files.delete(dir);
      System.out.println("delete dir: " + dir.toString());
      return FileVisitResult.CONTINUE;
    }
  });
} catch(IOException e){
  e.printStackTrace();
}

    from:https://www.cnblogs.com/liangblog/p/8920579.html

龙生   02 Nov 2021
View Details

Java NIO系列教程（十 五）Java NIO Path

原文链接  译者：章筱虎 Path接口是java NIO2的一部分。首次在java 7中引入。Path接口在java.nio.file包下，所以全称是java.nio.file.Path。 java中的Path表示文件系统的路径。可以指向文件或文件夹。也有相对路径和绝对路径之分。绝对路径表示从文件系统的根路径到文件或是文件夹的路径。相对路径表示从特定路径下访问指定文件或文件夹的路径。相对路径的概念可能有点迷糊。不用担心，我将在本文的后面详细介绍相关细节。 不要将文件系统的path和操作系统的环境变量path搞混淆。java.nio.file.Path接口和操作系统的path环境变量没有任何关系。 在很多方面，java.nio.file.Path接口和java.io.File有相似性，但也有一些细微的差别。在很多情况下，可以用Path来代替File类。 创建Path实例 为了使用java.nio.file.Path实例，必须首先创建它。可以使用Paths 类的静态方法Paths.get()来产生一个实例。以下是示例：

1
2
3
4
5
6
7
8
9
10
11
import java.nio.file.Path;
import java.nio.file.Paths;
 
public class PathExample {
 
public static void main(String[] args) {
 
Path path = Paths.get("c:\\data\\myfile.txt");
 
}
}

请注意例子开头的两个import语句。想要使用Paths类和Path接口，必须首先引入相应包。其次，注意Paths.get(“c:\\data\\myfile.txt”)的用法。其使用了Paths.get方法创建了Path的实例。它是一个工厂方法。 创建绝对路径Path 调用传入绝对路径当做参数的Paths.get()工厂方法，就可以生成绝对路径Path。示例如下：

1
Path path = Paths.get("c:\\data\\myfile.txt");

示例中的绝对路径是c:\data\myfile.txt。有两个\字符的原因是第一个\是转义字符，表示紧跟着它的字符需要被转义。\\表示需要向字符串中写入一个\字符。 上文示例的path是windows下的路径。在Unix系统(Linux,MacOS,FreeBSD等)中，上文中的path是这样的：

1
Path path = Paths.get("/home/jakobjenkov/myfile.txt");

/home/jakobjenkov/myfile.txt就称作绝对路径。 如果把以/开头path的格式运行在windows系统中，系统会将其解析为相对路径。例如：

1
/home/jakobjenkov/myfile.txt

将会被解析为路径是在C盘。对应的绝对路径是： C:/home/jakobjenkov/myfile.txt 创建相对路径Path 相对路径指从一个已确定的路径开始到某一文件或文件夹的路径。将确定路径和相对路径拼接起来就是相对路径对应的绝对路径地址。 java NIO Path类也能使用相对路径。可以通过Paths.get(basePath, relativePath)创建一个相对路径Path。示例如下：

1
2
3
Path projects = Paths.get("d:\\data", "projects");
 
Path file = Paths.get("d:\\data", "projects\\a-project\\myfile.txt");

第一个例子创建了一个指向d:\data\projects文件夹的实例。第二个例子创建了一个指向 d:\data\projects\a-project\myfile.txt 文件的实例。 当使用相对路径的时候，可以使用如下两种特别的符号。它们是： . .. .表示当前路径。例如，如果以如下方式创建一个相对路径：

1
2
Path currentDir = Paths.get(".");
System.out.println(currentDir.toAbsolutePath());

创建的Path实例对应的路径就是运行这段代码的项目工程目录。 如果.用在路径中，则其表示的就是当前路径下。示例： Path currentDir = Paths.get(“d:\\data\\projects\.\a-project”); 对应的就是如下路径 d:\data\projects\a-project ..表示父类目录。示例： Path parentDir = Paths.get(“..”); Path对应的路径是当前运行程序目录的上级目录。 如果在path中使用..，表示上级目录的含义。例如：

1
2
String path = "d:\\data\\projects\\a-project\\..\\another-project";
Path parentDir2 = Paths.get(path);

对应的绝对路径地址为： d:\data\projects\another-project 在a-project目录后面的..符号，将指向的目录修改为projects目录，因此，最终path指向another-project目录。 .和..都可以在Paths.get()的双形参方法中使用。示例：

1
2
3
4
Path path1 = Paths.get("d:\\data\\projects", ".\\a-project");
 
Path path2 = Paths.get("d:\\data\\projects\\a-project",
"..\\another-project");

下面介绍NIO 的Path类有关相对路径的其他使用方法。 Path.normalize() Path 的normalize()方法可以标准化路径。标准化的含义是路径中的.和..都被去掉，指向真正的路径目录地址。下面是Path.normalize()示例：

1
2
3
4
5
6
7
8
String originalPath =
"d:\\data\\projects\\a-project\\..\\another-project";
 
Path path1 = Paths.get(originalPath);
System.out.println("path1 = " + path1);
 
Path path2 = path1.normalize();
System.out.println("path2 = " + path2);

上文示例，首先创建了一个包含..字符的路径地址。之后输出此路径。 之后，调用normalize方法，返回一个新的path对象。输出新对象的路径。 输出结果如下：

1
2
path1 = d:\data\projects\a-project\..\another-project
path2 = d:\data\projects\another-project

如你所见，标准化后的路径不再包含 a-project\..部分，因为它是多余的。   from:https://ifeve.com/java-nio-path-2/

龙生   02 Nov 2021
View Details

Groovy从入门到精通

一、环境搭建 安装好JDK环境 到groovy官网下载groovySDK，解压到合适位置 groovy官网：http://www.groovy-lang.org/ 安装后的文件如上图所示，我们需要关注的是bin和doc文件夹下的内容，其它文件夹下是一些配置和groovy自带的一些jar包 配置groovy环境变量 二、与Java的不同之处 1、默认 imports 所有这些包和类都是默认导入的，您不必使用显式import语句来使用它们：

1
2
3
4
5
6
7
8
java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*

  2、运行时分派 在Groovy中，将在运行时选择将被调用的方法。 这称为运行时分派或Multi-methods。 这意味着将基于运行时参数的类型来选择方法。 在Java中，则是根据声明的类型，在编译时选择方法。 下面的代码，以Java代码编写，可以在Java和Groovy中编译，但它的行为会有所不同：

1
2
3
4
5
6
7
8
int method(String arg) {
    return 1;
}
int method(Object arg) {
    return 2;
}
Object o = "Object";
int result = method(o);

  在Java中, 您将得到：2 而在Groovy中：1 这是因为Java将使用静态信息类型，即o被声明为Object，而Groovy将在运行时选择该方法被实际调用时。 因为它是用String调用的，所以调用String版本。 3、数组初始化 在Groovy中，{…}块是为闭包而保留的。 这意味着您不能使用以下语法创建数组：

1
int [] array = {1，2，3}

  你必须使用：

1
int [] array = [1,2,3]

  4、自动资源管理块 Groovy不支持Java 7中的ARM（自动资源管理）块。 相反，Groovy提供了依赖闭包的各种方法，它们具有相同的效果，同时更加方便。 例如：

1
2
3
4
5
6
7
8
9
10
11
Path file = Paths.get("/path/to/file");
Charset charset = Charset.forName("UTF-8");
try (BufferedReader reader = Files.newBufferedReader(file, charset)) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
 
} catch (IOException e) {
    e.printStackTrace();
}

  可以这样写：

1
2
3
new File('/path/to/file').eachLine('UTF-8') {
   println it
}

  或者，如果你想要一个更接近Java的版本：

1
2
3
4
5
new File('/path/to/file').withReader('UTF-8') { reader ->
   reader.eachLine {
       println it
   }
}

  5、Lambdas Java 8支持lambdas和方法引用：

1
2
Runnable run = () -> System.out.println("Run");
list.forEach(System.out::println);

  Java 8 lambdas可以或多或少被认为是匿名内部类。 Groovy不支持该语法，但是可以使用闭包：

1
2
Runnable run = { println 'run' }
list.each { println it } // or list.each(this.&println)

  6、GStrings 由于双引号字符串字面量被解释为GString，Groovy将在GString和String之间自动转换 Groovy中的单引号用于String，双引号结果是String或GString，取决于文字中是否有插值。

1
2
3
assert 'c'.getClass()==String
assert "c".getClass()==String
assert "c${1}".getClass() in GString

  只有在赋给char类型的变量时，Groovy会自动将单字符String转换为char。 当调用类型为char的参数的方法时，我们需要显式转换或确保该值已预先转换。

1
2
3
4
5
6
7
8
9
char a='a'
assert Character.digit(a, 16)==10 : 'But Groovy does boxing'
assert Character.digit((char) 'a', 16)==10
 
try {
  assert Character.digit('a', 16)==10
  assert false: 'Need explicit cast'
} catch(MissingMethodException e) {
}

  Groovy支持两种类型的转换，在转换为char的情况下，在转换multi-char 时存在微妙的差别。 Groovy风格的转换是更宽松的，将采取第一个字符，而C风格的转换将失败，异常。

1
2
3
4
5
6
7
8
9
10
11
12
// for single char strings, both are the same
assert ((char) "c").class==Character
assert ("c" as char).class==Character
 
// for multi char strings they are not
try {
  ((char) 'cx') == 'c'
  assert false: 'will fail - not castable'
} catch(GroovyCastException e) {
}
assert ('cx' as char) == 'c'
assert 'cx'.asType(char) == 'c'

  7、原始和封装 因为Groovy使用Objects来做每一件事，它对原始的引用自动包装。 因此，它不遵循Java的扩展优先于装箱。 这里有一个使用int的例子

1
2
3
4
5
6
7
8
9
10
11
12
int i
m(i)
 
//这是Java将调用的方法，因为扩展优先于装箱。
void m(long l) {
  println "in m(long)"
}
 
//这是Groovy实际调用的方法，因为所有的基本引用都使用它们的包装类。
void m(Integer i) {
  println "in m(Integer)"
}

  8、==的行为 在Java中==表示对象的原始类型或标识的相等性。 在Groovy ==翻译为a.compareTo(b)== 0，如果他们是可比较的，否则a.equals(b)。 如果要检查身份，有is方法，例如a.is(b) 三、基础语法 1、动态类型 Groovy定义变量时：可以用Groovy风格的def声明，不指定类型；也可以兼容Java风格，指定变量类型；甚至还可以省略def或类型。

1
2
3
def t1 = 't1'
String t2 = 't2'
t3 = 't3'

  […]

龙生   01 Nov 2021
View Details

SpringBoot读取resource中的文件

1
2
3
4
5
6
//使用File获取resources里面资源文件的相对路径 若文件名称为中文可能会报文件不存在
File file = new File(this.getClass().getResource("/province-city.josn").getPath());
 
 
//使用inputStream
InputStream inputStream = this.getClass().getResourceAsStream("/province-city.json");

  from:https://www.cnblogs.com/yang-xiansen/p/13529568.html

龙生   28 Oct 2021
View Details

IDEA 停止在 Synchronizing output directories

重新Rubuild Project   停止在   运行时错误：     试着的解决方式    运行clean 、install  、运行。 运行正常！！   解决方法 删除 .idea ，重新打开项目 ，重新建立工程Rebuild Project ,信息如下： java: /E:/JPADemo/src/main/java/com/example/jpademo/JpaDemoApplication.java使用了未经检查或不安全的操作。 要取消这种告警信息，可在 public class JpaDemoApplication 类面前加@SuppressWarnings("unchecked")   原因：JAVA是一门安全性比较高的语言，它在编译之类要进行类型等一系列的检查。如果你使用了注解就可以告诉编译器不用检查，这样子就可以避过编译时期间的安全检查，这样子的效率会提高 。但同时 安全性就大打折扣了。 但是运行正常！！   from:https://www.cnblogs.com/wfy680/p/15014376.html

龙生   24 Oct 2021
View Details

使用IntelliJ IDEA 体验Groovy开发

使用IntelliJ IDEA开发groovy，创建一个项目进入到这个界面: 如果Groovy. library是no. library select 那就点击右侧的create按钮,选择你安装的groovy目录就可以, 如果IntelliJ IDEA 左侧没有Groovy选项的话那就安装groovy插件, 新建的groovy项目是这样的: 会发现并不是像我们Android 在studio下创建项目一样有一个默认的MainActivity,groovy是没有的，那么从事编程开发的入门都是从hello world开始的，那么现在创建一个hello.groovy文件

1
2
3
4
5
6
7
8
9
class Hello {
public static void main(String[] args){
print("hello world groovy")
}
}

  这是我们创建的第一个类Hello.groovy 从上面的代码就可以提现出groovy是完全支持Java的 而且更方便的是我们在控制台输入一句话 直接使用println()方法就行,相当于Java中的静态导包功能. 还有更神奇的写法: 是不是groovy很强大 这个写法和上面的Java中的写法结果是一样的.如果想弄懂gradle 构建是有必须去学习下.   from:https://blog.csdn.net/coderinchina/article/details/89600861

龙生   22 Oct 2021
View Details

idea报错Cannot compile Groovy files: no Groovy library is defined for module 'xx’之方

0、病因描写 clone 原有的项目（新建的项目一般不会有） IntelliJ IDEA 关联了后缀为groovy的文件但是没有配置Groovy的library。 1、病因一之解决方法 病因：本项目不需要用的Groovy但是关联了groovy了文件 方子：那直接去掉后缀为groovy的关联即可 结果：良好，网上基本都是这种方子 如图：去掉红框部分并apply 2、病因二之解决之法 病因：项目需要groovy的library。 方子：那就是配置groovy的library咯。 步骤： ①、下载groovy library ②、解压（选一个中意的目录，最好目录路径是全英文的） ③、配置groovy library：File —>Project Structure —> Modules —> Groovy —> Add Groovy Support —> 选择 Groovy library 最后 apply就OK了。 如图： 快捷配置入口：如果IDEA有如下提示就最好了–方便。直接点击 Configuration Groovy SDK 即可。   from:https://www.2cto.com/kf/201803/732193.html

龙生   21 Oct 2021
View Details

NuGet修改默认包保存的位置

NuGet默认的全局包下载地址一般为:C:\Users\{username}\.nuget\packages     修改方法：  

1
2
3
4
5
6
7
8
9
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <add key="Microsoft Visual Studio Offline Packages" value="C:\Program Files (x86)\Microsoft SDKs\NuGetPackages\"/>
  </packageSources>
  <config>
     <add key="globalPackagesFolder" value="D:\Nuget\.nuget\packages" />
  </config>
</configuration>

  from:https://www.cnblogs.com/sword88/p/11490304.html

龙生   19 Oct 2021
View Details

springboot整合mongodb，并配置账户名和密码登录验证

springboot pom.xml加入依赖

1
2
3
    org.springframework.boot
    spring-boot-starter-data-mongodb
    2.1.6.RELEASE

application.yml加入连接信息 mapper编写

1
2
public interface BusinessLogRecordMapper extends MongoRepository<businesslogrecord,string> {
}

Application启动添加注解

1
@EnableMongoRepositories(basePackages = {"com.etc.mapper"})

application.yml配置，这里之前碰到一个坑，mongodb的配置没有写host和port属性，只写了database和uri，这种方式在无密码验证的情况下，可以连接mongodb。但是在mongodb设置了密码登录后，就无法连接，一直提示 Caused by: com.mongodb.MongoCommandException: Command failed with error 13: 'not authorized on wxsb_dev to execute command { insert 这里我们说下，application.yml关于mongodb的两种配置 第一种，yml方式，注意这里的host port username password database，每个属性都要配置。

1
2
3
4
5
6
7
8
spring:
  data:
    mongodb:
      host: 192.168.11.121
      port: 27017
      username: aroot
      password: 999999
      database: udb

  第二种，uri方式

1
2
3
4
spring:
  data:
    mongodb:
      uri: mongodb://aroot:999999@192.168.11.121:27017/udb

  之前就是配了如下的参数，导致一直出错，还以为是mongodb的用户权限配置出错导致，原来是配置文件出错，报错信息 Caused by: com.mongodb.MongoCommandException: Command failed with error 13: 'not authorized on wxsb_dev to execute command { insert

1
2
3
4
5
6
7
spring:
  data:
    mongodb:
      database: udb
      uri: mongodb://192.168.11.111:27017
      username: aroot
      password: 999999

  from:https://www.it610.com/article/1283088113266081792.htm

龙生   18 Oct 2021
View Details

这个开源组织里的项目都是精品

前言 在开源中国里，不知道大家有没有留意到一个Java开源组织——Dromara？ 这个组织是由Apache ShenYu（前身是Soul网关）的作者创立，多位Java开源作者参与的一个Java开源组织。 在开源中国社区，很多Java开源作者都是各自为战，独立运营项目。Domara组织的诞生就是为了联合Java开源的力量，共建社区，资源共享，共同推行中国Java开源事业的发展。 目前Dromara社区拥有9个GVP项目，和一些Star数量很高的项目。这些开源项目社区都很活跃，每一个都是能提高工作效率的精品开源作品。下面就来盘点下Dromara组织其中的4个开源项目。都是非常实用的工具，用好这些将会让你的生产效率大大提升！ Sa-Token 首先我要介绍的是Sa-Token，可能是史上功能最全的轻量级 Java 权限认证框架。 简单的使用方式，丰富的特性，强大的功能，你有什么理由拒绝？ 官方网站：sa-token.dev33.cn/ Gitee托管仓库：gitee.com/dromara/sa-… Github托管仓库：github.com/dromara/Sa-… Sa-Token 是一个轻量级 Java 权限认证框架，主要解决：登录认证、权限认证、Session会话、单点登录、OAuth2.0、微服务网关鉴权 等一系列权限相关问题。 Sa-Token 的 API 设计非常简单，有多简单呢？以登录认证为例，你只需要：

1
2
3
4
5
6
// 在登录时写入当前会话的账号id
StpUtil.login(10001);
 
// 然后在需要校验登录处调用以下方法：
// 如果当前会话未登录，这句代码会抛出 `NotLoginException` 异常
StpUtil.checkLogin();

  至此，我们已经借助 Sa-Token 完成登录认证！ 此时的你小脑袋可能飘满了问号，就这么简单？自定义 Realm 呢？全局过滤器呢？我不用写各种配置文件吗？ 没错，在 Sa-Token 中，登录认证就是如此简单，不需要任何的复杂前置工作，只需这一行简单的API调用，就可以完成会话登录认证！ 当你受够 Shiro、SpringSecurity 等框架的三拜九叩之后，你就会明白，相对于这些传统老牌框架，Sa-Token 的 API 设计是多么的简单、优雅！ 权限认证示例（只有具备 user:add 权限的会话才可以进入请求）

1
2
3
4
5
6
@SaCheckPermission("user:add")
@RequestMapping("/user/insert")
public String insert(SysUser user) {
// ...
return "用户增加";
}

  将某个账号踢下线（待到对方再次访问系统时会抛出NotLoginException异常）

1
2
// 使账号id为 10001 的会话强制注销登录
StpUtil.logoutByLoginId(10001);

  在 Sa-Token 中，绝大多数功能都可以 一行代码 完成：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
StpUtil.login(10001);                     // 标记当前会话登录的账号id
StpUtil.getLoginId();                     // 获取当前会话登录的账号id
StpUtil.isLogin();                        // 获取当前会话是否已经登录, 返回true或false
StpUtil.logout();                         // 当前会话注销登录
StpUtil.logoutByLoginId(10001);           // 让账号为10001的会话注销登录（踢人下线）
StpUtil.hasRole("super-admin");           // 查询当前账号是否含有指定角色标识, 返回true或false
StpUtil.hasPermission("user:add");        // 查询当前账号是否含有指定权限, 返回true或false
StpUtil.getSession();                     // 获取当前账号id的Session
StpUtil.getSessionByLoginId(10001);       // 获取账号id为10001的Session
StpUtil.getTokenValueByLoginId(10001);    // 获取账号id为10001的token令牌值
StpUtil.login(10001, "PC");               // 指定设备标识登录，常用于“同端互斥登录”
StpUtil.logoutByLoginId(10001, "PC");     // 指定设备标识进行强制注销 (不同端不受影响)
StpUtil.openSafe(120);                    // 在当前会话开启二级认证，有效期为120秒
StpUtil.checkSafe();                      // 校验当前会话是否处于二级认证有效期内，校验失败会抛出异常
StpUtil.switchTo(10044);                  // 将当前会话身份临时切换为其它账号

  即使不运行测试，相信您也能意会到绝大多数 API 的用法。 想要了解更多请参考：gitee.com/dromara/sa-… Forest 一款极大程度解放你的Http接入工作的强大Http客户端框架。 Http协议很复杂吗？那是因为你还没有使用过Forest，虽然业内有很多其他优秀的Http客户端，但是你错过了Forest，将会错过一大片优雅美丽的森林。 官方网站：forest.dtflyx.com Gitee托管仓库：gitee.com/dromara/for… Github托管仓库：github.com/dromara/for… Forest 是一个开源的 Java HTTP 客户端框架，用来访问第三方服务 RESTful 接口。 它能够将 HTTP 的请求参数绑定到 Java 接口上，之后调用 Java 接口就等于在发送 HTTP 请求。一切面向于接口。 很多公司需要在 Java 后台调用许多第三方 HTTP 接口，比如微信支付、友盟等等第三方平台。 公司内部还有很多服务是用世界最好语言写的，接口自然也只能通过 HTTP […]

龙生   13 Oct 2021
View Details
1 … 40 41 42 … 177

Copyright © 2026 Longsheng All rights reserved