penruins

导航

Java

IO

tools

public static String is2String(InputStream is) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    StringBuilder builder= new StringBuilder();
    String line = "";
    while ((line = br.readLine()) != null) {
        builder.append(line);
    }
    return builder.toString();
}

Map

Base64

import sun.misc.BASE64Encoder;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class ImageUtils {
    /**
     * 网络图片转换 Base64 的方法
     * @param netImagePath
     * @return
     */
    public static String netImageToBase64(String netImagePath) {
        ByteArrayOutputStream data = new ByteArrayOutputStream();
        try {
            URL url = new URL(netImagePath);
            byte[] bytes = new byte[1024];

            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setConnectTimeout(5000);
            InputStream is = conn.getInputStream();

            int len = -1;
            while ((len = is.read(bytes)) != -1) {
                data.write(bytes,0,len);
            }
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        BASE64Encoder encoder = new BASE64Encoder();
        return encoder.encode(data.toByteArray());
    }

    /**
     * 本地图片转换 Base64 的方法
     * @param imgPath
     * @return
     */
    public static String imageToBase64(String imgPath) {
        InputStream in = null;
        byte[] data = null;
        try {
            in = new FileInputStream(imgPath);
            data = new byte[in.available()];
            in.read(data);
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        BASE64Encoder encoder = new BASE64Encoder();
        String encode = encoder.encode(data);
        return encode.replaceAll("\r\n", "");
    }

    public static void main(String[] args) {
//        String url = "https://img1.doubanio.com/view/status/l/public/7adc8e05420f989.webp";
//        String base = netImageToBase64(url);
//        System.out.println(base);

        String imgPath = "D:\\hik_data\\reference\\111.jpg";
        String base = imageToBase64(imgPath);
        System.out.println(base);
    }
}

database

  • DriverManager
    • DriverManager类是Java.sql包中用于数据库驱动程序管理的类，作用于用户和驱动程序之间。它跟踪可用的驱动程序，并在数据库和相应驱动程序之间建立连接，也处理诸如驱动程序登录时间限制及登录和跟踪消息的显示等事务。
  • Connection
    • Connection是用来表示数据库连接的对象，对数据库的一切操作都是在这个连接的基础上进行的。
  • statement
    • Statement用于在已经建立的连接的基础上向数据库发送SQL语句的对象。它只是一个接口的定义，其中包括了执行SQL语句和获取返回结果的方法。
    • 实际上有3种 Statement 对象
      • Statement 对象用于执行不带参数的简单 SQL 语句
        • Statement 接口提供了3种执行SQL语句的方法：executeQuery、executeUpdate和execute
          • executeQuery 方法用于产生单个结果集的SQL语句，如SELECT语句
          • executeUpdate 方法用于执行INSERT、UPDATE、DELETE及DDL（数据定义语言）语句，例如CREATE TABLE 和 DROP TABLE。executeUpdate 的返回值是一个整数，表示它执行的SQL语句所影响的数据库中的表的行数（更新计数）
          • execute 方法用于执行返回多个结果集或多个更新计数的语句
      • PreparedStatement 对象用于执行带或不带 IN 参数的预编译 SQL 语句
      • CallableStatement 对象用于执行对数据库已存储过程的调用
        • CallableStatement cstmt = con.prepareCall("{call getData(?, ?)}");
    • PreparedStatement与Statement的区别在于它构造的SQL语句不是完整的语句，而需要在程序中进行动态设置。这一方面增强了程序设计的灵活性；另一方面，由于PreparedStatement语句是经过预编译的，因此它构造的SQL语句的执行效率比较高。所以对于某些使用频繁的SQL语句，用PreparedStatement语句比用Statement具有明显的优势
  • ResultSet
    • 结果集（ResultSet）用来暂时存放数据库查询操作获得的结果。它包含了符合 SQL 语句中条件的所有行，并且它提供了一套 get 方法对这些行中的数据进行访问。
  • reference

连接数据库

public class T0001 {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        Class.forName("org.postgresql.Driver");
        Connection connection = DriverManager.getConnection("jdbc:postgresql://xx.xx.xx.xx:port/db_name","username","password");
        System.out.println(connection.isClosed());
    }
}
// 返回 connection.isClosed() -------> false 说明连接成功

简单查表

import java.sql.*;

public class T0001 {
    public static void main(String[] args) throws SQLException, ClassNotFoundException {
        Class.forName("org.postgresql.Driver");
        Connection connection = DriverManager.getConnection("jdbc:postgresql://10.19.131.84:7092/penruins","xxxx","xxxxx");
        System.out.println("connection.isClosed() -------> " + connection.isClosed());
        Statement statement = connection.createStatement();
        ResultSet resultSet = statement.executeQuery("select * from dummy_table");
        while (resultSet.next()) {
            System.out.println(resultSet.getString(1) + " "
                + resultSet.getString(2) + " " + resultSet.getString(3));
        }
    }
}

string

annotation

自定义注解

import com.penruins.irds.annotation.MyAnnotation;
import lombok.Builder;
import lombok.Data;

@Data
@Builder
@MyAnnotation(isDelete = false)
public class Person {
    private String name;
    private int age;
    private boolean isDelete;
}

import java.lang.annotation.*;

@Target({ElementType.FIELD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnnotation {
    String value() default "penruins";
    boolean isDelete();
}

import com.penruins.irds.annotation.MyAnnotation;
import com.penruins.irds.entity.annotation.Person;

public class T0001 {
    public static void main(String[] args) {
        Person p = Person.builder().build();
        Class clazz = p.getClass();
        // 判断 person 对象上是否有 MyAnnotation 注解
        if (clazz.isAnnotationPresent(MyAnnotation.class)) {
            System.out.println("Person类上配置了Info注解！");
            //获取该对象上Info类型的注解
            MyAnnotation anno = (MyAnnotation) clazz.getAnnotation(MyAnnotation.class);
            System.out.println("person.name :" + anno.value() + ",person.isDelete:" + anno.isDelete());
        } else {
            System.out.println("Person类上没有配置Info注解！");
        }
    }
/*
execute result 

Person类上配置了Info注解！
person.name :penruins,person.isDelete:false

*/

}

json

java8

Maven

http

  • 长连接

    • 首先解释一下什么是长连接，当我们向一台服务器发起请求时，我们需要和对方建立一条通道，去传输数据，所谓的短连接，就是说我们建立起了通道，然后在传输完数据，就把通道摧毁，下次需要的时候再重新去建立通道。长连接呢，就是指，我们建立了一条通道，传递完数据后，先不摧毁，下次如果还需要传输数据，就复用这条通道。因为通道的建立是需要花费时间的，所以长连接的优势就在于响应速度快，但是服务器压力大，因为同时有很多人在向服务器建立通道，即便有些通道已经传输完数据了，由于长连接的原因，通道也不会被摧毁；短连接呢，则是，响应速度慢，服务器压力小。由于现在更多的是强调用户的体验，所以长连接目前是最常见的。

  • reference

HttpURLConnection

  • 任何网络连接都需要经过socket才能连接，HttpURLConnection不需要设置socket，所以，HttpURLConnection并不是底层的连接，而是在底层连接上的一个请求。这就是为什么 HttpURLConneciton 只是一个抽象类，自身不能被实例化的原因。HttpURLConnection只能通过URL.openConnection()方法创建具体的实例

  • 虽然底层的网络连接可以被多个HttpURLConnection实例共享，但每一个HttpURLConnection实例只能发送一个请求。请求结束之后，应该调用HttpURLConnection实例的InputStream或OutputStream的close()方法以释放请求的网络资源，不过这种方式对于持久化连接没用。对于持久化连接，得用disconnect()方法关闭底层连接的socket

  • reference

HttpClient

密码学

Hash

  • 什么是单向函数？
    • 单向函数 (One-way function)是一种具有下述特点的单射函数：对于每一个输入，函数值都容易计算（多项式时间），但是给出一个随机输入的函数值，算出原始输入却比较困难
    • reference
  • 什么是 Hash
    • 　Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。
  • 什么是hash表?
    • 哈希表是根据设定的哈希函数H（key）和处理冲突方法将一组关键字映射到一个有限的地址区间上，并以关键字在地址区间中的象作为记录在表中的存储位置，这种表称为哈希表或散列，所得存储位置称为哈希地址或散列地址。作为线性数据结构与表格和队列等相比，哈希表无疑是查找速度比较快的一种。
  • 什么是抗碰撞性
    • 使用相同的消息，产生的散列值一定相同。使用不同的消息，产生的散列值也不相同，哪怕只有一个比特的差别，得到的散列值也会有很大区别。这一特性叫抗碰撞性，对于抗碰撞性弱的算法，我们不应该使用
  • hash 函数的含义
    • Hash函数还有另外的含义。实际中的Hash函数是指把一个大范围映射到一个小范围。把大范围映射到一个小范围的目的往往是为了节省空间，使得数据容易保存。除此以外，Hash函数往往应用于查找上
  • hash 的应用
    • 文件 hash 值
      • 　MD5-Hash-文件的数字文摘通过Hash函数计算得到。不管文件长度如何，它的Hash函数计算结果是一个固定长度的数字。与加密算法不 同，这一个Hash算法是一个不可逆的单向函数。采用安全性高的Hash算法，如MD5、SHA时，两个不同的文件几乎不可能得到相同的Hash结果。因 此，一旦文件被修改，就可检测出来。
      • 用户下载后，计算其散列值，对比结果是否相同，从而校验文件的完整性
    • 用户密码保护
      • 用户在设置密码时，不记录密码本身，只记录密码的散列值，只有用户知道密码的明文。校验密码时，只要输入的密码正确，得到的散列值一定是一样的，表示校验正确。使用散列值存储密码的好处是：即使数据库被盗，也无法将密文反推出明文是什么，使密码保存更安全
    • 云盘秒传
      • 当我们上传一个文件时，云盘客户端会先为该文件生成一个散列值。拿着这个散列值去数据库中匹配，如果匹配到，说明该文件已经在云服务器存在。只需将该散列值与用户进行关联，便可完成本次“上传”。 这样，一个文件在云服务器上只会存一份，大大节约了云服务器的空间。
  • reference

code

加法hash

public class T0001 {
    public static void main(String[] args) {
        System.out.println(additiveHash("you dont give up then there's no limitation", 3));
    }
    /**
     * 所谓的加法Hash就是把输入元素一个一个的加起来构成最后的结果。
     * 这里的prime是任意的质数，看得出，结果的值域为[0,prime-1]
     * @param key
     * @param prime
     * @return
     */
    public static int additiveHash(String key, int prime) {
        int hash = key.length();
        for(int i=0;i<key.length();i++) {
            hash += key.charAt(i);
        }
        return hash % prime;
    }
}

X509

mq

ActiveMQ

producer

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

/**
 * Created by Intellij IDEA
 * Author: liuxiang37
 * Date: 2022/1/14
 */
public class Test001Producer {
    public static void main(String[] args) throws JMSException {
        // 创建 ConnectionFactory
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("admin","vr3vDI32","tcp://10.19.131.84:7018");
        // 创建Connection
        Connection connection = connectionFactory.createConnection();
        // 启动连接
        connection.start();
        // 创建会话
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        // 创建一个目标
        Destination destination = session.createQueue("hik-penruins-penruins");
        // 创建一个生产者
        MessageProducer producer = session.createProducer(destination);
        for(int i=0;i<10;i++) {
            // 创建消除
            TextMessage textMessage = session.createTextMessage("hello point ------> " + i);
            // 发送消息
            producer.send(textMessage);
            System.out.println("yes ------>" + i);
        }
        // 关闭连接
        connection.close();
    }
}

consumer

import org.apache.activemq.ActiveMQConnectionFactory;
import javax.jms.*;

public class Test002Consumer {
    public static void main(String[] args) throws JMSException {
        ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("admin","vr3vDI32","tcp://10.19.131.84:7018");
        Connection connection = connectionFactory.createConnection();
        connection.start();
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        Destination destination = session.createQueue("hik-penruins-penruins");
        MessageConsumer consumer = session.createConsumer(destination);
        consumer.setMessageListener(new MessageListener() {
            @Override
            public void onMessage(Message message) {
                TextMessage textMessage = (TextMessage) message;
                try {
                    System.out.println(textMessage.getText());
                } catch (JMSException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

design pattern

  • 创建型模式
    • 工厂方法模式
    • 抽象工厂模式
    • 单例模式
    • 建造者模式
    • 原型模式
  • 结构性模式
    • 适配器模式
    • 装饰者模式
    • 代理模式
    • 外观模式
    • 桥接模式
    • 组合模式
    • 享元模式
  • 行为型模式
    • 策略模式
    • 模板方法模式
    • 观察者模式
    • 迭代子模式
    • 责任链模式
    • 命令模式
    • 备忘录模式
    • 状态模式
    • 访问者模式
    • 中介者模式
    • 解释器模式

观察者模式

状态模式

责任链模式

享元模式 Flyweight

适配器模式

装饰者模式

  • 对于装饰者最重要的是利用组合代替了继承，原有逻辑交给内部引用的类来实现，而自己只做增强功能，只要符合这一思想都可以称之为装饰者模式
  • reference

builder

  • 遇到多个构造器参数时考虑构造器
public class Configuration {
  private String username;
  private String password;
  private String url;

  public Configuration(String username, String password, String url) {
    this.username = username;
    this.password = password;
    this.url = url;
  }

  public static ConfigurationBuilder builder() {
    return new ConfigurationBuilder();
  }

  public static class ConfigurationBuilder {
    private String username;
    private String password;
    private String url;

    ConfigurationBuilder() {
    }

    public ConfigurationBuilder username(String username) {
      this.username = username;
      return this;
    }

    public ConfigurationBuilder password(String password) {
      this.password = password;
      return this;
    }

    public ConfigurationBuilder url(String url) {
      this.url = url;
      return this;
    }

    public Configuration build() {
      // can some check
      return new Configuration(this.username, this.password, this.url);
    }

    public String toString() {
      return new StringBuilder().append((String)"Configuration.ConfigurationBuilder(username=")
                .append((String)this.username).append((String)", password=")
                .append((String)this.password).append((String)", url=")
                .append((String)this.url).append((String)")").toString();
    }
  }
}

functional programming

Mess

posted on 2022-01-20 14:27  penruins  阅读(77)  评论(0)  编辑  收藏  举报