0%

What is

Java Persistence API is a collection of classes and methods to persistently store the vast amounts of data into a database which is provided by the Oracle Corporation.

Where to use

To reduce the burden of writing codes for relational object management, a programmer follows the ‘JPA Provider’ framework, which allows easy interaction with database instance. Here the required framework is taken over by JPA.

  • JPA Pro

    JPA is an open source API, therefore various enterprise vendors such as Oracle, Redhat, Eclipse, etc. provide new products by adding the JPA persistence flavor in them. Some of these products include:Hibernate, Eclipselink, Toplink, Spring Data JPA, etc.

Architecture

  • jpa class relationships

  • ORM Architecture

  • Entity Relationships

    • @ManyToOne Relation
    • @OneToMany Relation
    • @OneToOne Relation
    • @ManyToMany Relation

Creating Java Streams

  1. We can use Stream.of() to create a stream from similar type of data. For example, we can create Java Stream of integers from a group of int or Integer objects.
    1
    Stream<Integer> stream = Stream.of(1,2,3,4);
  2. We can use Stream.of() with an array of Objects to return the stream. Note that it doesn’t support autoboxing, so we can’t pass primitive type array.
    1
    2
    3
    4
    5
    Stream<Integer> stream = Stream.of(new Integer[]{1,2,3,4}); 
    //works fine

    Stream<Integer> stream1 = Stream.of(new int[]{1,2,3,4});
    //Compile time error, Type mismatch: cannot convert from Stream<int[]> to Stream<Integer>
  3. We can use Collection stream() to create sequential stream and parallelStream() to create parallel stream.
    1
    2
    3
    4
    5
    6
    7
    8
    List<Integer> myList = new ArrayList<>();
    for(int i=0; i<100; i++) myList.add(i);

    //sequential stream
    Stream<Integer> sequentialStream = myList.stream();

    //parallel stream
    Stream<Integer> parallelStream = myList.parallelStream();
  4. We can use Stream.generate() and Stream.iterate() methods to create Stream.
    1
    2
    Stream<String> stream1 = Stream.generate(() -> {return "abc";});
    Stream<String> stream2 = Stream.iterate("abc", (i) -> i);
  5. Using Arrays.stream() and String.chars() methods.
    1
    2
    LongStream is = Arrays.stream(new long[]{1,2,3,4});
    IntStream is2 = "abc".chars();

Converting Java Stream to Collection or Array

  1. We can use java Stream collect() method to get List, Map or Set from stream.
    1
    2
    3
    4
    5
    6
    7
    Stream<Integer> intStream = Stream.of(1,2,3,4);
    List<Integer> intList = intStream.collect(Collectors.toList());
    System.out.println(intList); //prints [1, 2, 3, 4]

    intStream = Stream.of(1,2,3,4); //stream is closed, so we need to create it again
    Map<Integer,Integer> intMap = intStream.collect(Collectors.toMap(i -> i, i -> i+10));
    System.out.println(intMap); //prints {1=11, 2=12, 3=13, 4=14}
  2. We can use stream toArray() method to create an array from the stream.
    1
    2
    3
    Stream<Integer> intStream = Stream.of(1,2,3,4);
    Integer[] intArray = intStream.toArray(Integer[]::new);
    System.out.println(Arrays.toString(intArray)); //prints [1, 2, 3, 4]

Java Stream Intermediate Operations

  1. Stream filter() : We can use filter() method to test stream elements for a condition and generate filtered list.
    1
    2
    3
    4
    5
    6
    7
    8
    List<Integer> myList = new ArrayList<>();
    for(int i=0; i<100; i++) myList.add(i);
    Stream<Integer> sequentialStream = myList.stream();

    Stream<Integer> highNums = sequentialStream.filter(p -> p > 90); //filter numbers greater than 90
    System.out.print("High Nums greater than 90=");
    highNums.forEach(p -> System.out.print(p+" "));
    //prints "High Nums greater than 90=91 92 93 94 95 96 97 98 99 "
  2. Stream map() : We can use map() to apply functions to an stream. Let’s see how we can use it to apply upper case function to a list of Strings.
    1
    2
    3
    4
    5
    Stream<String> names = Stream.of("aBc", "d", "ef");
    System.out.println(names.map(s -> {
    return s.toUpperCase();
    }).collect(Collectors.toList()));
    //prints [ABC, D, EF]
  3. Stream sorted() : We can use sorted() to sort the stream elements by passing Comparator argument.
    1
    2
    3
    4
    5
    6
    7
    Stream<String> names2 = Stream.of("aBc", "d", "ef", "123456");
    List<String> reverseSorted = names2.sorted(Comparator.reverseOrder()).collect(Collectors.toList());
    System.out.println(reverseSorted); // [ef, d, aBc, 123456]

    Stream<String> names3 = Stream.of("aBc", "d", "ef", "123456");
    List<String> naturalSorted = names3.sorted().collect(Collectors.toList());
    System.out.println(naturalSorted); //[123456, aBc, d, ef]
  4. Stream flatMap() : We can use flatMap() to create a stream from the stream of list. Let’s see a simple example to clear this doubt.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    Stream<List<String>> namesOriginalList = Stream.of(
    Arrays.asList("Pankaj"),
    Arrays.asList("David", "Lisa"),
    Arrays.asList("Amit"));
    //flat the stream from List<String> to String stream
    Stream<String> flatStream = namesOriginalList
    .flatMap(strList -> strList.stream());

    flatStream.forEach(System.out::println);

Java Stream Terminal Operations

  1. Stream reduce() example: We can use reduce() to perform a reduction on the elements of the stream, using an associative accumulation function, and return an Optional. Let’s see how we can use it multiply the integers in a stream.
    1
    2
    3
    4
    Stream<Integer> numbers = Stream.of(1,2,3,4,5);

    Optional<Integer> intOptional = numbers.reduce((i,j) -> {return i*j;});
    if(intOptional.isPresent()) System.out.println("Multiplication = "+intOptional.get()); //120
  2. Stream count() example: We can use this terminal operation to count the number of items in the stream.
    1
    2
    Stream<Integer> numbers1 = Stream.of(1,2,3,4,5);
    System.out.println("Number of elements in stream="+numbers1.count()); //5
  3. Stream forEach() example: This can be used for iterating over the stream. We can use this in place of iterator. Let’s see how to use it for printing all the elements of the stream.
    1
    2
    Stream<Integer> numbers2 = Stream.of(1,2,3,4,5);
    numbers2.forEach(i -> System.out.print(i+",")); //1,2,3,4,5,
  4. Stream match() examples: Let’s see some of the examples for matching methods in Stream API.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Stream<Integer> numbers3 = Stream.of(1,2,3,4,5);
    System.out.println("Stream contains 4? "+numbers3.anyMatch(i -> i==4));
    //Stream contains 4? true

    Stream<Integer> numbers4 = Stream.of(1,2,3,4,5);
    System.out.println("Stream contains all elements less than 10? "+numbers4.allMatch(i -> i<10));
    //Stream contains all elements less than 10? true

    Stream<Integer> numbers5 = Stream.of(1,2,3,4,5);
    System.out.println("Stream doesn't contain 10? "+numbers5.noneMatch(i -> i==10));
    //Stream doesn't contain 10? true
  5. Stream findFirst() :This is a short circuiting terminal operation, let’s see how we can use it to find the first string from a stream starting with D.
    1
    2
    3
    4
    5
    Stream<String> names4 = Stream.of("Pankaj","Amit","David", "Lisa");
    Optional<String> firstNameWithD = names4.filter(i -> i.startsWith("D")).findFirst();
    if(firstNameWithD.isPresent()){
    System.out.println("First Name starting with D="+firstNameWithD.get()); //David
    }

some example

1
2
3
4
5
6
//merge collection
List<String> resultPersonnos = Stream.of(list1, list2)
.flatMap(Collection::stream)
.distinct()
.sorted()
.collect(Collectors.toList());

  • 安装插件

    CTRL + SHIFT + P并且输入Package Control: Install Package

  • html格式化

    输入!,然后按 TAB

  • Pretty JSON插件

    格式化 CTRL + ALT + J

语法

  • 设置标签属性

    $("div").attr("属性名","属性值");

  • 设置标签样式

    $("div").css("color","yellow"); $("div").css("padding-left"))

  • 移除属性

    $("div").removeAttr("id");

  • 遍历数组

    • 原生js有两种方法都可以使用[for(var i;i<arr.length;i++){},for(var i in arr){}]

    • jquery有两个函数共计四种方法都可以使用

      1
      2
      3
      4
      $.each(arr,function(i,item){}),
      $(arr).each(function(i,item){}),
      $.map(arr,function(i,item){}),
      $(arr).map(function(i,item){})
  • 遍历对象

    • 原生js有一种方法可以使用[for(var i in obj){}]

    • jquery有两个函数共计两种方法可以使用

      1
      2
      $.each(obj,function(i,item){})
      $.map(obj,function(i,item){})
  • Jquery中的ajax在默认不写async情况下,请求为异步请求;即:async:true

  • $(function(){ })是定义一个匿名函数,它是$(document).ready(function(){})的简写

关于代码编译的事情

  • 问题

    • 由于一些配置项写在统一的配置文档中,代码从配置文件中读取确定的配置项;此时操作的文本路径是要追加上根目录的路径,然而开发环境和生成环境是不一样的。项目在打包的过程中,就确定了文本路径,这样导致两边环境的配置文档读取结果不一致。
  • 解决办法

    • 把文件路径精确写入
    • 在生成环境下编译代码

关于读取数据量大的excel文件

  • 问题

    • 项目部署到tomcat中,每次读取大于1M的文件时,会停滞在org.apache.poi.ss.usermodel.Workbook workbook = new XSSFWorkbook(is);,直到tomcat出现报错信息java.lang.OutOfMemoryError: Java heap space ,即java虚拟机堆溢出的错误。
  • 现象描述

    • 手动设置Xms,Xmx的大小,在/bin/catalina.bat(windows环境)配置中,添加JAVA_OPTS="-server -Xms10G -Xmx20G",不知道什么原因,重启服务,仍旧报一样的错。(当我在自己电脑上运行程序,操作同样大小的文档时,也没有报错,何况自己电脑才8G内存,远不及服务器,再则就是自身电脑tomcat的配置也是默认的)

    • 内存总体分为年轻代(young),老年代(old),永久代(permanent),如图

      7OCHl.jpg

PORT

  • Check the listening ports

    Run any one of the following command:

    1
    2
    3
    sudo lsof -i -P -n | grep LISTEN 
    sudo netstat -tulpn | grep LISTEN
    sudo nmap -sTU -O IP-address-Here
  • checking remote system tcp 80 port status

    1. Telnet

    2. nc

      1
      2
      3
      4
      5
       nc -zvw10 192.168.0.1 22
      其中参数:
      z: zero-I/O mode which is used for scanning
      v: for verbose output
      w10: timeout wait seconds
  1. nmap
    1
    2
    3
    4
    telnet myserver.com 80 
    nc -v myserver.com 80
    nc -vn 192.168.40.146 2424
    nmap myserver.com 80
  • 通过进程名查看占用端口

    • 先查看进程pid ps -ef | grep 进程名
    • 再通过pid查看占用端口 netstat -nap | grep 进程pid
  • 通过端口查看进程

    1
    2
    netstat -an | grep <portnumber>
    lsof -i:<portnumber>

进程号

  • 根据进程号查看启动文件所在位置

    readlink /proc/<线程ID>/exe

  • 查看进程的启动命令

    cat /proc/<线程ID>/cmdline

网络代理

  • 查看本地网络代理

    1
    export | grep -i proxy
  • 关闭代理

    1
    unset http_proxy 

curl

  • pretty json

    curl ‘address:port’ | json_pp

端口远程访问

检测端口是否允许远程访问

1
2
3
4
netstat -an | grep <port>

查看输出结果。如果输出结果中有 0.0.0.0:<port> 或者 :::<port>,表示该端口允许远程访问;
如果输出结果中只有 127.0.0.1:<port> 或者 ::1:<port>,表示该端口只允许本地访问
  • 在 Ubuntu 中,要开启指定端口的远程访问,需要进行以下步骤:
  1. 确认端口是否已经开启:使用 netstat 命令检查要开启的端口是否已经在监听状态。如果已经在监听状态,则可以直接进行下一步操作;如果没有在监听状态,则需要先启动对应的服务程序。

  2. 修改防火墙规则:使用 ufw 命令修改防火墙规则,开放指定端口。例如,要开放端口号为 80 的端口,可以使用以下命令:

    1
    sudo ufw allow 80/tcp

    这个命令会将端口号为 80 的端口加入到防火墙规则中,并允许 TCP 协议通过该端口进行访问。

  3. 重启防火墙服务:在修改防火墙规则后,需要重启防火墙服务才能使修改生效。可以使用以下命令重启防火墙服务:

    1
    sudo service ufw restart
  4. 确认防火墙规则是否正确:使用以下命令查看当前的防火墙规则:

    1
    sudo ufw status numbered

根据PID查看子进程

1
netstat -lntp |grep PID

子网掩码

xx.xx.xx.xx/24

在网络中,IP地址由两个部分组成:网络地址和主机地址。IP地址的网络部分用于标识网络,而主机部分用于标识特定的设备或主机。

CIDR(无类别域间路由)表示法通常用于指定IP地址的子网掩码,以确定网络地址和主机地址的边界。CIDR表示法使用斜线后面的数字来表示网络地址中前多少位是固定的,即网络前缀长度。例如,/24 表示前 24 位是网络地址,剩下的 8 位则是主机地址。

对于 IPv4 地址,每个 IP 地址都由 32 位二进制数表示。通过将前 24 位作为网络地址并保留最后 8 位作为主机地址,可以创建一个包含 256 个可能主机地址的网络。这被称为 “24 位网络” 或 “24 位子网”,它的子网掩码是 255.255.255.0。

因此,当你配置一个 IP 地址并添加 /24 后缀时,你正在指定该地址所属的网络和子网掩码。这样可以帮助确定该地址所在的网络,并确保与其他设备进行通信时,数据包能够正确地路由到目标设备。

  • /bin/ 用以存储二进制可执行命令文件,/usr/bin/也存储了一些基于用户的命令文件。
  • /sbin/ 许多系统命令的存储位置,/usr/sbin/中也包括了许多命令。
  • /root/ 超级用户,即根用户的主目录。
  • /home/ 普通用户的默认目录,在该目录下,每个用户拥有一个以用户名命名的文件夹。
  • /boot/ 存放Ubuntu内核和系统启动文件。
  • /mnt/ 通常包括系统引导后被挂载的文件系统的挂载点。
  • /dev/ 存储设备文件,包括计算机的所有外部设备,如硬盘、是、键盘、鼠标等。
  • /etc/ 存放文件管理配置文件和目录。
  • /lib/ 存储各种程序所需要的共享库文件。
  • /lost+found/ 一般为空,当非法关机时,会存放一些零散的文件。
  • /var/ 用于存放很多不断变化的文件,例如日志文件等。
  • /usr/ 包括与系统用户直接有关的文件和目录
  • /media/ 存放Ubuntu系统自动挂载的设备文件。
  • /proc/ 这是一个虚拟目录,它是内存的映射,包括系统信息和进程信息。
  • /tmp/ 存储系统和用户的临时信息。
  • /initrd/ 用来加载启动时临时挂载的initrd.img映像文件,以及载入所要的设备模块目录。
  • /opt/ 作为可选文件和程序的存放目录,否则将无法引导计算机进入操作系统。
  • /srv/ 存储系统提供的服务数据。
  • /sys/ 系统设备和文件层次结构,并向用户程序提供详细的内核数据信息。

装机问题

Wifi Not Enabled Acer Aspire 4750

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
~$ rfkill list all
0: phy0: Wireless LAN
Soft blocked: no
Hard blocked: yes

~$ sudo rmmod acer-wmi
​```

add below line at the end of the file : /etc/modprobe.d/blacklist.conf
blacklist acer-wmi

Then restart the system.
~$ rfkill list all
0: phy0: Wireless LAN
Soft blocked: no
Hard blocked: no

服务

  • 防火墙 firewalld.service

shell

shell与export命令

用户登录到Linux系统后,系统将启动一个用户shell。在这个shell中,可以使用shell命令或声明变量,也可以创建并运行 shell脚本程序。运行shell脚本程序时,系统将创建一个子shell。此时,系统中将有两个shell,一个是登录时系统启动的shell,另一 个是系统为运行脚本程序创建的shell。当一个脚本程序运行完毕,它的脚本shell将终止,可以返回到执行该脚本之前的shell。从这种意义上来 说,用户可以有许多 shell,每个shell都是由某个shell(称为父shell)派生的。

在子 shell中定义的变量只在该子shell内有效。如果在一个shell脚本程序中定义了一个变量,当该脚本程序运行时,这个定义的变量只是该脚本程序内 的一个局部变量,其他的shell不能引用它,要使某个变量的值可以在其他shell中被改变,可以使用export命令对已定义的变量进行输出。 export命令将使系统在创建每一个新的shell时定义这个变量的一个拷贝。这个过程称之为变量输出。

操作文件名中含有“-”的文件

  • 使用转移字符 “–”, 比如查看文件“-abc.txt“,命令为 vim -- -abc.txt

KVM

KVM 的全称是:Kernel-based Virtual Machine,简单一句话概括,就是一个基于 Linux 内核的虚拟化管理系统。

  • what is cache ? why use cache ?
    1. Cache是高速缓冲存储器 一种特殊的存储器子系统,其中复制了频繁使用的数据以利于快速访问
    2. 凡是位于速度相差较大的两种硬件/软件之间的,用于协调两者数据传输速度差异的结构,均可称之为 Cache
  • 缓存的分类
    • 操作系统磁盘缓存->减少磁盘机械操作
    • 数据库缓存->减少文件系统I/O
    • 应用程序缓存->减少对数据库的查询
    • Web服务器缓存->减少应用服务器请求
    • 客户端浏览器缓存->减少对网站的访问

技术框架

  • Encache
    • 设计于提高在数据从RDBMS中取出来的高花费、高延迟采取的一种缓存方案
    • java编写,直接在jvm虚拟机中缓存,速度快,效率高;但是缓存共享麻烦,集群分布式应用不方便。
    • 特点:
      • 简单
      • 袖珍
      • 轻量
      • 扩展
      • 监听器
  • memcache
    • 一种高性能、分布式对象缓存系统,最初设计于缓解动态网站数据库加载数据的延迟性,你可以把它想象成一个大的内存HashTable,就是一个key-value键值缓存。
    • C语言编写
    • 特点:
      • 依赖
      • 多线程支持
      • 高性能
  • redis
    • 通过socket访问到缓存服务,效率比encache低,比数据库要快很多,处理集群和分布式缓存方便,有成熟的方案。
    • 特性:
      • 支持持久化
      • 丰富的数据类型
      • 高性能
      • 主从复制

other snippet

generate code based proto file

protoc --proto_path=扫描目录 --java_out=代码生成目录 proto文件目录

protoc –proto_path=src –java_out=build/gen src/foo.proto

Spring provides three way of scheduling:

  • @Scheduled
  • Via Quartz
  • Via JDK Timer

one word

  • \x对应的是UTF-8编码的数据