unsafe类

2022年10月10日 17:10 周一

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

sun.misc.Unsafe

提供执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，效率快，但由于有了操作内存空间的能力，会增加指针问题风险。且这些功能的实现依赖于本地方法，Java代码中只是声明方法头，具体实现规则交给本地代码

为什么要使用本地方法 #

• 需要用到Java中不具备的依赖于操作系统的特性，跨平台的同时要实现对底层控制
• 对于其他语言已经完成的现成功能，可以使用Java调用
• 对时间敏感/性能要求非常高，有必要使用更为底层的语言

对于同一本地方法，不同的操作系统可能通过不同的方式来实现的

Unsafe创建 #

sun.misc.Unsafe部分源码

public final class Unsafe {
  // 单例对象
  private static final Unsafe theUnsafe;
  ......
  private Unsafe() {
  }
    
  //Sensitive : 敏感的 英[ˈsensətɪv]
  @CallerSensitive
  public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    // 仅在引导类加载器`BootstrapClassLoader`加载时才合法
    if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
      throw new SecurityException("Unsafe");
    } else {
      return theUnsafe;
    }
  }
}

会先判断当前类是否由Bootstrap classloader加载。即只有启动类加载器加载的类才能够调用Unsafe类中的方法

如何使用Unsafe这个类

1. 利用反射获得Unsafe类中已经实例化完成的单例对象theUnsafe

   private static Unsafe reflectGetUnsafe() {
       try {
         Field field = Unsafe.class.getDeclaredField("theUnsafe");
         field.setAccessible(true);
         return (Unsafe) field.get(null);
       } catch (Exception e) {
         log.error(e.getMessage(), e);
         return null;
       }
   }
   

2. 通过Java命令行命令-Xbootclasspath/a把调用Unsafe相关方法的类A所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载

   ...

big_decimal

2022年10月10日 14:56 周一

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

精度的丢失 #

float a = 2.0f - 1.9f;
float b = 1.8f - 1.7f;
System.out.println(a);// 0.100000024
System.out.println(b);// 0.099999905
System.out.println(a == b);// false

为什么会有精度丢失的风险

这个和计算机保存浮点数的机制有很大关系。我们知道计算机是二进制的，而且计算机在表示一个数字时，宽度是有限的，无限循环的小数存储在计算机时，只能被截断，所以就会导致小数精度发生损失的情况。这也就是解释了为什么浮点数没有办法用二进制精确表示

使用BigDecimal来定义浮点数的值，然后再进行浮点数的运算操作即可

BigDecimal常见方法 #

• 我们在使用 BigDecimal 时，为了防止精度丢失，推荐使用它的BigDecimal(String val)构造方法或者 BigDecimal.valueOf(double val) 静态方法来创建对象

• 加减乘除

  BigDecimal a = new BigDecimal("1.0");
  BigDecimal b = new BigDecimal("0.9");
  System.out.println(a.add(b));// 1.9
  System.out.println(a.subtract(b));// 0.1
  System.out.println(a.multiply(b));// 0.90
  System.out.println(a.divide(b));// 无法除尽，抛出 ArithmeticException 异常
  System.out.println(a.divide(b, 2, RoundingMode.HALF_UP));// 1.11
  

  使用divide方法的时候，尽量使用3个参数版本（roundingMode.oldMode)

• 保留规则

  public enum RoundingMode {
     // 2.5 -> 3 , 1.6 -> 2
     // -1.6 -> -2 , -2.5 -> -3
  			 UP(BigDecimal.ROUND_UP), //数轴上靠近哪个取哪个
     // 2.5 -> 2 , 1.6 -> 1
     // -1.6 -> -1 , -2.5 -> -2
  			 DOWN(BigDecimal.ROUND_DOWN), //数轴上离哪个远取哪个
  			 // 2.5 -> 3 , 1.6 -> 2
     // -1.6 -> -1 , -2.5 -> -2
  			 CEILING(BigDecimal.ROUND_CEILING),
  			 // 2.5 -> 2 , 1.6 -> 1
     // -1.6 -> -2 , -2.5 -> -3
  			 FLOOR(BigDecimal.ROUND_FLOOR), ////数轴上 正数：远离哪个取哪个  负数：靠近哪个取哪个
     	// 2.5 -> 3 , 1.6 -> 2
     // -1.6 -> -2 , -2.5 -> -3
  			 HALF_UP(BigDecimal.ROUND_HALF_UP),// 数轴上 正数：靠近哪个取哪个  负数：远离哪个取哪个
     //......
  }
  

• 大小比较
  使用compareTo

  ...

Java代理模式

2022年10月10日 14:30 周一

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

代理模式 #

使用代理对象来代替对真实对象的访问，就可以在不修改原目标对象的前提下提供额外的功能操作，扩展目标对象的功能，即在目标对象的某个方法执行前后可以增加一些自定义的操作

静态代理 #

静态代理中，我们对目标对象的每个方法的增强都是手动完成的（*后面会具体演示代码*），非常不灵活（*比如接口一旦新增加方法，目标对象和代理对象都要进行修改*）且麻烦(*需要对每个目标类都单独写一个代理类*）。 实际应用场景非常非常少，日常开发几乎看不到使用静态代理的场景。

上面我们是从实现和应用角度来说的静态代理，从 JVM 层面来说， 静态代理在编译时就将接口、实现类、代理类这些都变成了一个个实际的 class 文件。

1. 定义一个接口及其实现类；
2. 创建一个代理类同样实现这个接口
3. 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法。这样的话，我们就可以通过代理类屏蔽对目标对象的访问，并且可以在目标方法执行前后做一些自己想做的事情。

代码:

//定义发送短信的接口
public interface SmsService {
    String send(String message);
}
//实现发送短信的接口
public class SmsServiceImpl implements SmsService {
    public String send(String message) {
        System.out.println("send message:" + message);
        return message;
    }
}
//创建代理类并同样实现发送短信的接口
public class SmsProxy implements SmsService {

    private final SmsService smsService;

    public SmsProxy(SmsService smsService) {
        this.smsService = smsService;
    }

    @Override
    public String send(String message) {
        //调用方法之前，我们可以添加自己的操作
        System.out.println("before method send()");
        smsService.send(message);
        //调用方法之后，我们同样可以添加自己的操作
        System.out.println("after method send()");
        return null;
    }
}
//实际使用
public class Main {
    public static void main(String[] args) {
        SmsService smsService = new SmsServiceImpl();
        SmsProxy smsProxy = new SmsProxy(smsService);
        smsProxy.send("java");
    }
}
//打印结果
before method send()
send message:java
after method send()

动态代理 #

从JVM角度来说，动态代理是在运行时动态生成类字节码，并加载到JVM中的。 SpringAOP和RPC等框架都实现了动态代理

java-reflex

2022年10月10日 11:27 周一

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

何为反射 #

赋予了我们在运行时分析类以及执行类中方法的能力；运行中获取任意一个类的所有属性和方法，以及调用这些方法和属性

应用场景 #

Spring/Spring Boot 、MyBatis等框架都用了大量反射机制，以下为

• JDK动态代理

  • 接口及实现类

        package proxy;
    
        public interface Car {
    
            public void run();
        }
        //实现类
        package proxy;
    
        public class CarImpl implements Car{
    
            public void run() {
                System.out.println("car running");
            }
    
        }
    

  • 代理类 及main方法使用 [ˌɪnvəˈkeɪʃn] 祈祷

    package proxy;
    
      import java.lang.reflect.InvocationHandler;
      import java.lang.reflect.Method;
      //JDK动态代理代理类 
      public class CarHandler implements InvocationHandler{
          //真实类的对象
          private Object car;
          //构造方法赋值给真实的类
          public CarHandler(Object obj){
              this.car = obj;
          }
      //代理类执行方法时，调用的是这个方法
          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
              System.out.println("before");
              Object res = method.invoke(car, args);
              System.out.println("after");
              return res;
          }
      }
      //main方法使用
    package proxy;
    
    import java.lang.reflect.Proxy;
    
    public class main {
    
          public static void main(String[] args) {
              CarImpl carImpl = new CarImpl();
              CarHandler carHandler = new CarHandler(carImpl);
              Car proxy = (Car)Proxy.newProxyInstance(
                      main.class.getClassLoader(), //第一个参数，获取ClassLoader
                      carImpl.getClass().getInterfaces(), //第二个参数，获取被代理类的接口
                      carHandler);//第三个参数，一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
              proxy.run();
          }
      }
    //输出
    before
    car running
    after
    

• Cglib动态代理（没有实现接口的Car

  ...

Java序列化详解

2022年10月10日 10:39 周一

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

什么是序列化？什么是反序列化 #

当需要持久化Java对象，比如将Java对象保存在文件中、或者在网络中传输Java对象，这些场景都需要用到序列化

即：

• 序列化：将数据结构/对象，转换成二进制字节流
• 反序列化：将在序列化过程中所生成的二进制字节流，转换成数据结构或者对象的过程

对于Java，序列化的是对象(Object)，也就是实例化后的类(Class)

序列化的目的，是通过网络传输对象，或者说是将对象存储到文件系统、数据库、内存中，如图：

实际场景 #

• 对象在进行网络传输（比如远程方法调用 RPC 的时候）之前需要先被序列化，接收到序列化的对象之后需要再进行反序列化；
• 将对象存储到文件中的时候需要进行序列化，将对象从文件中读取出来需要进行反序列化。
• 将对象存储到缓存数据库（如 Redis）时需要用到序列化，将对象从缓存数据库中读取出来需要反序列化

序列化协议对于TCP/IP 4层模型的哪一层 #

4层包括，网络接口层，网络层，传输层，应用层 如下图所示：

OSI七层协议模型中，表示层就是对应用层的用户数据，进行处理转换成二进制流；反过来的话，就是将二进制流转换成应用层的用户数据，即序列化和反序列化，
因为，OSI 七层协议模型中的应用层、表示层和会话层对应的都是 TCP/IP 四层模型中的应用层，所以序列化协议属于 TCP/IP 协议应用层的一部分

常见序列化协议对比 #

kryo 英音 [k’rɪəʊ] ，除了JDK自带的序列化，还有hessian、kryo、protostuff

• JDK自带的序列化，只需要实现java.io.Serializable接口即可

  @AllArgsConstructor
  @NoArgsConstructor
  @Getter
  @Builder
  @ToString
  public class RpcRequest implements Serializable {
      private static final long serialVersionUID = 1905122041950251207L;
      private String requestId;
      private String interfaceName;
      private String methodName;
      private Object[] parameters;
      private Class<?>[] paramTypes;
      private RpcMessageTypeEnum rpcMessageTypeEnum;
  }
  

  serialVersionUID用于版本控制，会被写入二进制序列，反序列化如果发现和当前类不一致则会抛出InvalidClassException异常。一般不使用JDK自带序列化，1 不支持跨语言调用 2 性能差，序列化之后字节数组体积过大

  ...

为什么Java中只有值传递

2022年10月9日 11:30 周日

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

• 形参&&实参

  • 实参(实际参数，Arguments)，用于传递给函数/方法的参数，必须有确定的值

  • 形参(形式参数，Parameters)，用于定义函数/方法，接收实参，不需要有确定的值

    String hello = "Hello!";
    // hello 为实参
    sayHello(hello);
    // str 为形参
    void sayHello(String str) {
        System.out.println(str);
    }
    

• 值传递&&引用传递

  • 程序设计将实参传递给方法的方式分为两种，值传递：方法接收实参值的拷贝，会创建副本；引用传递：方法接受的是实参所引用的对象在堆中的地址，不会创建副本，对形参的修改将影响到实参

• Java中只有值传递，原因：

  • 传递基本类型参数

    public static void main(String[] args) {
        int num1 = 10;
        int num2 = 20;
        swap(num1, num2);
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
    }
    
    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
    //输出
    a = 20
    b = 10
    num1 = 10
    num2 = 20
    

  • 传递引用类型参数 1

    ...

javaGuide基础3

2022年10月8日 15:23 周六

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

异常 #

• unchecked exceptions (运行时异常)
  checked exceptions (非运行时异常，编译异常）

• Java异常类层次结构图

  

• Exception和Error有什么区别

  • 除了RuntimeException及其子类以外，其他的Exception类及其子类都属于受检查异常

  • Exception : 程序本身可以处理的异常（可通过catch捕获）

    • Checked Exception ，受检查异常，必须处理(catch 或者 throws ，否则编译器通过不了) IOException，ClassNotFoundException，SQLException，FileNotFoundException

    • Unchecked Exception ， 不受检查异常 ， 可以不处理

（算数异常，类型转换异常，不合法的线程状态异常，下标超出异常，空指针异常，参数类型异常，数字格式异常，不支持操作异常） ArithmeticException，ClassCastException，IllegalThreadStateException，IndexOutOfBoundsException

  NullPointerException，IllegalArgumentException，NumberFormatException，SecurityException，UnsupportedOperationException 


  ```illegal 英[ɪˈliːɡl] 非法的```  
  ```Arithmetic 英[əˈrɪθmətɪk] 算术```

• Error： 程序无法处理的错误 ，不建议通过catch 捕获，已办错误发生时JVM会选择线程终止
  OutOfMemoryError （堆，Java heap space），VirtualMachineError，StackOverFlowError，AssertionError （断言），IOError

• Throwable类常用方法

  • String getMessage() //简要描述
  • String toString() //详细
  • String getLocalizedMessage() //本地化信息，如果子类(Throwable的子类)没有覆盖该方法，则与gtMessage() 结果一样
  • void printStackTrace() //打印Throwable对象封装的异常信息

• try-catch-finally如何使用 try后面必须要有catch或者finally；无论是否捕获异常，finally都会执行；当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。

  ...

javaGuide基础2

2022年9月29日 10:16 周四

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

面向对象基础 #

• 区别

  • 面向过程把解决问题的过程拆成一个个方法，通过一个个方法的执行解决问题。
  • 面向对象会先抽象出对象，然后用对象执行方法的方式解决问题。
  • 面向对象编程 易维护、易复用、易扩展

• 对象实例与对象引用的不同
  new 运算符，new 创建对象实例（对象实例在堆内存中），对象引用指向对象实例（对象引用存放在栈内存中）。

  一个对象引用可以指向 0 个或 1 个对象（一根绳子可以不系气球，也可以系一个气球）;一个对象可以有 n 个引用指向它（可以用 n 条绳子系住一个气球）。

• 对象的相等一般比较的是内存中存放的内容是否相等；引用相等一般比较的是他们指向的内存地址是否相等

• 如果一个类没有声明构造方法，该程序能正确执行吗? 如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了

  • 构造方法特点：名字与类名相同；没有返回值但不能用void声明构造函数；生成类的对象时自动执行
  • 构造方法不能重写(override)，但能重载 (overload)

• 面向对象三大特征

  • 封装
    把一个对象的状态信息(属性)隐藏在对象内部，不允许直接访问，但提供可以被外界访问的方法来操作属性

    public class Student {
        private int id;//id属性私有化
        private String name;//name属性私有化
    
        //获取id的方法
        public int getId() {
            return id;
        }
    
        //设置id的方法
        public void setId(int id) {
            this.id = id;
        }
    
        //获取name的方法
        public String getName() {
            return name;
        }
    
        //设置name的方法
        public void setName(String name) {
            this.name = name;
        }
    }
    

  • 继承
    不通类型的对象，相互之间有一定数量的共同点，同时每个对象定义了额外的特性使得他们与众不同。继承是使用已存在的类的定义作为基础建立新类的技术

    ...

javaGuide基础1

2022年9月28日 10:51 周三

转载自https://github.com/Snailclimb/JavaGuide （添加小部分笔记）感谢作者!

基础概念及常识 #

• Java语言特点

  • 面向对象（封装、继承、多态）
  • 平台无关性（Java虚拟机）
  • 等等

• JVM并非只有一种，只要满足JVM规范，可以开发自己专属JVM

• JDK与JRE

  • JDK，JavaDevelopmentKit，包含JRE，还有编译器（javac）和工具（如javadoc、jdb）。能够创建和编译程序
  • JRE，Java运行时环境，包括Java虚拟机、Java类库，及Java命令等。但是不能创建新程序

• 字节码，采用字节码的好处

  • Java中，JVM可以理解的代码称为字节码（.class文件)，不面向任何处理器，只面向虚拟机
  • Java程序从源代码到运行的过程
    • java代码必须先编译为字节码，之后呢，.class–>机器码，这里JVM类加载器先加载字节码文件，然后通过解释器进行解释执行（也就是字节码需要由Java解释器来解释执行）
    • Java解释器是JVM的一部分

• 编译与解释并存

  • 编译型：通过编译器将源代码一次性翻译成可被该平台执行的机器码，执行快、开发效率低
  • 解释型：通过解释器一句一句的将代码解释成机器代码后执行，执行慢，开发效率高
  • 如图

• 为什么说 Java 语言“编译与解释并存”？

  这是因为 Java 语言既具有编译型语言的特征，也具有解释型语言的特征。因为 Java 程序要经过先编译，后解释两个步骤，由 Java 编写的程序需要先经过编译步骤，生成字节码（.class 文件），这种字节码必须由 Java 解释器来解释执行。

• Java与C++区别

  • 没学过C++，Java不提供指针直接访问内存
  • Java为单继承；但是Java支持继承多接口
  • Java有自动内存管理垃圾回收机制（GC），不需要程序员手动释放无用内存

• 注释分为 单行注释、多行注释、文档注释

• 标识符与关键字 标识符即名字，关键字则是被赋予特殊含义的标识符

• 自增自减运算符 当 b = ++a 时，先自增（自己增加 1），再赋值（赋值给 b）；当 b = a++ 时，先赋值(赋值给 b)，再自增（自己增加 1）

• continue/break/return

  • continue ：指跳出当前的这一次循环，继续下一次循环。
  • break ：指跳出整个循环体，继续执行循环下面的语句。
  • return 用于跳出所在方法，结束该方法的运行。

• 变量

  • 成员变量和局部变量
    • 成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰
    • 从变量在内存中的存储方式来看,如果成员变量是使用 static 修饰的，那么这个成员变量是属于类的，如果没有使用 static 修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。
    • 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动生成，随着方法的调用结束而消亡（即方法栈弹出后消亡）。
    • final必须显示赋初始值，其他都自动以类型默认值赋值
  • 静态变量：被类所有实例共享

• 字符型常量与字符串常量区别

  ...

作用域及事务

2022年9月23日 13:37 周五

四种作用域 #

• singleton：默认值，当IOC容器一创建就会创建bean实例，而且是单例的，每次得到的是同一个
• prototype：原型的，IOC容器创建时不再创建bean实例。每次调用getBean方法时再实例化该bean（每次都会进行实例化）
• request：每次请求会实例化一个bean
• session：在一次会话中共享一个bean

事务 #

事务是什么 #

逻辑上的一组操作，要么都执行，要么都不执行

事务的特性 #

ACID

• Atomicity /ˌætəˈmɪsəti/原子性 , 要么全部成功，要么全部失败
• Consistency /kənˈsɪstənsi/ 一致性 , 数据库的完整性
• Isolation /ˌaɪsəˈleɪʃn/ 隔离性 , 数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致 , 这里涉及到事务隔离级别
• Durability /ˌdjʊərəˈbɪləti/ 持久性 , 事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失

Spring支持两种方式的事务管理 #

• 编程式事务管理 /ˈeksɪkjuːt/ execute
  使用transactionTemplate

  @Autowired
  private TransactionTemplate transactionTemplate;
  public void testTransaction() {
  
          transactionTemplate.execute(new TransactionCallbackWithoutResult() {
              @Override
              protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
  
                  try {
  
                      // ....  业务代码
                  } catch (Exception e){
                      //回滚
                      transactionStatus.setRollbackOnly();
                  }
  
              }
          });
  }
  

  使用transactionManager

  ...