Java 11 –基于嵌套的访问控制

最新推荐文章于 2022-01-05 23:08:08 发布
最新推荐文章于 2022-01-05 23:08:08 发布
阅读量1.4k 收藏
点赞数 1
文章标签： java git 数据库

JEP 181：基于嵌套的访问控制 ，直接支持嵌套成员内部的私有访问，而不再通过自动生成的桥接方法access$000 。 此外，新的嵌套API用于验证并允许嵌套成员内的私有反射访问。

PS无需更改代码，这是Java编译器的优化，可删除桥接方法访问。

1.在Java 11之前，桥接方法access $ 000

1.1复查以下嵌套类。 所有嵌套类都尝试访问Alphabet的私有成员，即NestHost 。

Alphabet.java 
public class Alphabet {

    private String name = "I'm Alphabet!";

    public class A {
        public void printName() {
            System.out.println(name);       // access Alphabet's private member!
        }
    }

    public class B {
        public void printName() {
            System.out.println(name);       // access Alphabet's private member!
        }

        public class B1 {
            public void printName() {
                System.out.println(name);   // access Alphabet's private member!
            }
        }
    }
}

1.2如果我们编译上述源代码，它将生成四个类， Alphabet ， Alphabet$A ， Alphabet$B和Alphabet$B.B1 ，即使嵌套类也是具有唯一名称的典型类。 JVM访问规则将不允许不同类内的私有访问。

但是，Java允许嵌套成员内的私有访问，因此Java编译器创建了一个桥接方法access$000来应用于JVM访问规则。

Terminal 
$ javac Alphabet.java

Alphabet$A.class
Alphabet$B.class
Alphabet$B.B1.class
Alphabet.class

1.3桥接方法访问的源代码与此类似： 

public class Alphabet {
  private String name = "I'm Alphabet!";
  String access$000(){
    return name;
  }
}

public class Alphabet$A {
  final Alphabet obj;
  public void printName(){
    System.out.println(obj.access$000());
  }
}

public class Alphabet$B {
  final Alphabet obj;
  public void printName(){
    System.out.println(obj.access$000());
  }
}

public class Alphabet$B$B1 {
  final Alphabet$B this$1;
  public void printName(){
    System.out.println(obj.access$000());
  }
}

2.反汇编代码

我们可以使用javap -c来分解上述四个类，以查看桥接方法访问前后的差异。

2.1在Java 11之前，它会为嵌套的私有访问自动创建一个新的access$000桥接方法。

Terminal 
$ javac Alphabet.java

$ javap -c Alphabet
Compiled from "Alphabet.java"
public class Alphabet {
  public Alphabet();
    Code:
       0: aload_0
       1: invokespecial #2                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: ldc           #3                  // String I'm Alphabet!
       7: putfield      #1                  // Field name:Ljava/lang/String;
      10: return

  static java.lang.String access$000(Alphabet);
    Code:
       0: aload_0
       1: getfield      #1                  // Field name:Ljava/lang/String;
       4: areturn
}

$ javap -c Alphabet$A
Compiled from "Alphabet.java"
public class Alphabet$A {
  final Alphabet this$0;

  public Alphabet$A(Alphabet);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:LAlphabet;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$0:LAlphabet;
       7: invokestatic  #4                  // Method Alphabet.access$000:(LAlphabet;)Ljava/lang/String;
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: return
}

$ javap -c Alphabet$B
Compiled from "Alphabet.java"
public class Alphabet$B {
  final Alphabet this$0;

  public Alphabet$B(Alphabet);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:LAlphabet;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$0:LAlphabet;
       7: invokestatic  #4                  // Method Alphabet.access$000:(LAlphabet;)Ljava/lang/String;
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: return
}

$ javap -c Alphabet$B$B1
Compiled from "Alphabet.java"
public class Alphabet$B$B1 {
  final Alphabet$B this$1;

  public Alphabet$B$B1(Alphabet$B);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$1:LAlphabet$B;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$1:LAlphabet$B;
       7: getfield      #4                  // Field Alphabet$B.this$0:LAlphabet;
      10: invokestatic  #5                  // Method Alphabet.access$000:(LAlphabet;)Ljava/lang/String;
      13: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      16: return
}

2.2在Java 11中，它使用NO桥方法直接支持嵌套成员内的私有访问。

经过Java 11。

Terminal 
$ javac Alphabet.java

$ javap -c Alphabet
Compiled from "Alphabet.java"
public class Alphabet {
  public Alphabet();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: ldc           #2                  // String I\'m Alphabet!
       7: putfield      #3                  // Field name:Ljava/lang/String;
      10: return
}

$ javap -c Alphabet$A
Compiled from "Alphabet.java"
public class Alphabet$A {
  final Alphabet this$0;

  public Alphabet$A(Alphabet);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:LAlphabet;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$0:LAlphabet;
       7: getfield      #4                  // Field Alphabet.name:Ljava/lang/String;
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: return
}

$ javap -c Alphabet$B
Compiled from "Alphabet.java"
public class Alphabet$B {
  final Alphabet this$0;

  public Alphabet$B(Alphabet);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:LAlphabet;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$0:LAlphabet;
       7: getfield      #4                  // Field Alphabet.name:Ljava/lang/String;
      10: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      13: return
}

$ javap -c Alphabet$B$B1
Compiled from "Alphabet.java"
public class Alphabet$B$B1 {
  final Alphabet$B this$1;

  public Alphabet$B$B1(Alphabet$B);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$1:LAlphabet$B;
       5: aload_0
       6: invokespecial #2                  // Method java/lang/Object."<init>":()V
       9: return

  public void printName();
    Code:
       0: getstatic     #3                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #1                  // Field this$1:LAlphabet$B;
       7: getfield      #4                  // Field Alphabet$B.this$0:LAlphabet;
      10: getfield      #5                  // Field Alphabet.name:Ljava/lang/String;
      13: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      16: return
}

3.新的嵌套类API。

3.1一些用于验证嵌套成员的新API。

  • getNestHost
  • getNestMembers
  • isNestmateOf

例如，查看以下嵌套类。 Alphabet是NestHost ，所有其他Alphabet NestHost都是NestMembers或NestmateOf 。

Alphabet.java 
public class Alphabet {

    public class A {
    }

    public class B {
        public class B1 {
        }
    }
}

3.2以下源代码显示了新嵌套API的用法。 唯一的技巧是B.B1.class.getNestHost()返回Alphabet ，而不是B 其他结果很明显，请阅读注释。

Alphabet.java 
package com.mkyong.java11.jep181;

import java.util.Arrays;

public class Alphabet {

    private String name = "I'm Alphabet!";

    public class A {
        public void printName() {
            System.out.println(name);       // access Alphabet's private member!
        }
    }

    public class B {
        public void printName() {
            System.out.println(name);       // access Alphabet's private member!
        }

        public class B1 {
            public void printName() {
                System.out.println(name);   // access Alphabet's private member!
            }
        }
    }

    public static void main(String[] args) {

        A objA = new Alphabet().new A();
        objA.printName();

        B objB = new Alphabet().new B();
        objB.printName();

        B.B1 objB1 = new Alphabet().new B().new B1();
        objB1.printName();

        System.out.println(Alphabet.class.getNestHost());       // Alphabet
        System.out.println(A.class.getNestHost());              // Alphabet
        System.out.println(B.class.getNestHost());              // Alphabet
        System.out.println(B.B1.class.getNestHost());           // Alphabet!, not B

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

        System.out.println(Arrays.toString(Alphabet.class.getNestMembers()));   // Alphabet, Alphabet$A, Alphabet$B, Alphabet$B$B1
        System.out.println(Arrays.toString(A.class.getNestMembers()));          // Alphabet, Alphabet$A, Alphabet$B, Alphabet$B$B1
        System.out.println(Arrays.toString(B.class.getNestMembers()));          // Alphabet, Alphabet$A, Alphabet$B, Alphabet$B$B1
        System.out.println(Arrays.toString(B.B1.class.getNestMembers()));       // Alphabet, Alphabet$A, Alphabet$B, Alphabet$B$B1

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

        System.out.println(Alphabet.class.isNestmateOf(Alphabet.class));        // true
        System.out.println(Alphabet.class.isNestmateOf(A.class));               // true
        System.out.println(Alphabet.class.isNestmateOf(B.class));               // true
        System.out.println(Alphabet.class.isNestmateOf(B.B1.class));            // true

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

        System.out.println(A.class.isNestmateOf(Alphabet.class));               // true
        System.out.println(A.class.isNestmateOf(A.class));                      // true
        System.out.println(A.class.isNestmateOf(B.class));                      // true
        System.out.println(A.class.isNestmateOf(B.B1.class));                   // true

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

        System.out.println(B.class.isNestmateOf(Alphabet.class));               // true
        System.out.println(B.class.isNestmateOf(A.class));                      // true
        System.out.println(B.class.isNestmateOf(B.class));                      // true
        System.out.println(B.class.isNestmateOf(B.B1.class));                   // true

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

        System.out.println(B.B1.class.isNestmateOf(Alphabet.class));            // true
        System.out.println(B.B1.class.isNestmateOf(A.class));                   // true
        System.out.println(B.B1.class.isNestmateOf(B.class));                   // true
        System.out.println(B.B1.class.isNestmateOf(B.B1.class));                // true

    }
}

4.反射访问

3.1 InnerA尝试通过反射API访问InnerB私有方法。

Outer.java 
package com.mkyong.java11.jep181;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Outer {

    public static class InnerA {
        // InnerA access InnerB private method, via reflection!
        // Before Java 11 - IllegalAccessException
        // Java 11 - OK
        public void printName() throws NoSuchMethodException,
            InvocationTargetException, IllegalAccessException {

            InnerB obj = new InnerB();
            final Method m = InnerB.class.getDeclaredMethod("printName");
            m.invoke(obj);
        }
    }

    public static class InnerB {
        // private!!!
        private void printName() {
            System.out.println("I'm InnerB!");
        }
    }

    public static void main(String[] args) throws NoSuchMethodException,
        IllegalAccessException, InvocationTargetException {

        InnerA obj = new InnerA();
        obj.printName();
    }
}

在Java 11之前，它将引发java.lang.IllegalAccessException 。

Terminal 
Exception in thread "main" java.lang.IllegalAccessException: Class com.mkyong.java11.jep181.Outer$InnerA can not access a member of class com.mkyong.java11.jep181.Outer$InnerB with modifiers "private"

at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
at java.lang.reflect.Method.invoke(Method.java:491)
at com.mkyong.java11.jep181.Outer$InnerA.printName(Outer.java:14)
at com.mkyong.java11.jep181.Outer.main(Outer.java:28)

与Java 11一起运行，没问题。 新的基于嵌套的访问控制甚至可以通过反射API来私有访问嵌套成员。

Terminal 
I'm InnerB!

下载源代码

$ git clone https://github.com/mkyong/core-java
$ cd java-11
$ cd src / main / java / com / mkyong / java11 / jep181

参考文献

标签：

翻译自: https://mkyong.com/java/java-11-nest-based-access-control/

cyan20115
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java JDK11基于嵌套的访问控制的实现
08-26
主要介绍了Java JDK11基于嵌套的访问控制的实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java JDK11基于嵌套的访问控制
weixin_34192993的博客
01-23 170
Java（和其他语言）通过内部类支持嵌套类。要使其正常工作，需要编译器执行一些技巧。这是一个例子： public class Outer { private int outerInt; class Inner { public void printOuterInt() { System....
Java11 中基于嵌套关系的访问控制优化
沉潜飞动
01-05 3981
有人的地方就有江湖，有猿的地方就有 bug
java11新特性---Nest-Based Access Control(嵌套访问控制)
weixin_34013044的博客
09-29 1754
简介嵌套是一种访问控制上下文，它允许多个class同属一个逻辑代码块，但是被编译成多个分散的class文件，它们访问彼此的私有成员无需通过编译器添加访问扩展方法。动机很多jvm语言支持在一个源文件中放多个class。这对于用户是透明的，用户认为它们在一个class中，所以希望它们共享同一套访问控制体系。为了达到目的，编译器需要经常需要通过附加的access bridge扩大private成员的访问...
聊聊Jdk中你没听过的关键词-synthetic
NightWish- 的博客
11-08 351
文章目录前言什么是synthetic？作用和原理产生的问题什么是NBAC？ 前言 为什么要讲讲synthetic和NBAC呢？其实在这之前，对Jdk中这两种机制并不了解，甚至没有听过，主要原因还是因为在阅读SkyWalking中Agent源码过程中，有这么一行， AgentBuilder agentBuilder = new AgentBuilder.Default(byteBuddy).ignore( nameStartsWith("net.bytebuddy.")
Java的访问控制符
01-20
java的访问控制符分为两类：类的访问控制符，属性和方法的访问控制符。 　1. 类的访问控制符有两种：public， default(默认的，什么都不用写) 　default是包内访问控制符。 　当然对于内部类还可以有static修饰，...
java实现多层嵌套循环参数转换
06-20
在Java编程中，多层嵌套循环是一种常见的数据处理方式，尤其在处理具有层次关系的数据时，例如构建或解析父子级结构。在这种场景下，我们可能需要遍历多个层级的数据，以便进行转换、操作或者存储到数据库中。下面将...
Java中的嵌套循环教程
最新发布
03-22
### Java中的嵌套循环教程 #### 一、嵌套循环的重要性与应用场景 在Java编程语言中，嵌套循环是一种常见的编程技巧，它允许一个循环结构内部包含另一个循环结构。这种结构特别适用于处理多维数组、生成复杂的图形...
Java跳出多重嵌套循环代码实例
08-26
首先，我们来看一个传统的多重嵌套循环的例子，它使用了标志变量`flag`来控制退出循环： ```java int i = 0; boolean flag = true; while (flag) { while (true) { if (i > 50) { flag = false; // 设置标志为...
JDK 5 ~ 17 新特性倾情整理！（持续补充）
杀神吴起的智脑
09-28 1060
为了大家对JDK有一个全面的了解，下面我为大家整理了JDK5~17的所有关键新特性！ 随jdk发布，会持续补充 JDK5新特性 自动装箱与拆箱 枚举 静态导入 可变参数（Varargs） 内省（introspector） 泛型（Generic） For-Each循环 JDK6新特性 Desktop类和SystemTray类 使用JAXB2来实现对象与XML之间的映射 理解STAX 使用Compiler API 轻量级 Ht......
jdk11新特性研究
cxy_19891109的博客
09-17 456
1、基于嵌套的访问控制 public class NestAccessExample { public static class X { void test() throws Exception { Y y = new Y(); y.y = 1; //jdk8会报IllegalAccessException,除非加field.setAcces...
嵌套类和私有方法
最佳 Java 编程
06-10 288
当您在另一个类中有一个类时，他们可以看到彼此的private方法。 在Java开发人员中并不为人所知。 面试中的许多候选人说， private是一种可见性，它使代码可以查看成员是否属于同一班级。 这实际上是对的，但更准确地说，代码和成员都在一个类中。当我们嵌套了内部类时， private成员和使用它的代码可能会出现在同一班级，同时他们也处于不同的班级。 例如，如果我在一个顶级类中有两个嵌...
Java 11新特性
YunWisdom
03-09 201
Java 11新特性 我们还没有完全沉浸在Java 10中，而Java 11就在这里。Java 11的重要性不仅仅是几个原因。甲骨文已经改进了它的支持模式，并提出了一个大约每6个月就会带来快速更新的发布列车。 他们已经更改了许可和支持模式，这意味着如果您下载Java 11 Oracle JDK，它将被支付用于商业用途。 这是否意味着我需要从现在开始支付Java费用？没有。除非您下...
JDK 11新特性
weixin_33973609的博客
09-26 546
JDK 11中的新功能 - 新功能和增强功能 以下注释描述了JavaSE11和JDK11中的一些增强功能。这些描述可能包含指向更详细描述增强功能的其他文档的链接。此处描述的API是随Oracle JDK提供的API。它包括JavaSE11平台的完整实现和其他JavaAPI，以支持Java应用程序的开发，调试...
Java 11 新特性
记事本
10-21 1731
java 11 是继 java8 之后的第一个LTS版本。因此有必要针对它进行一些深入的学习，虽然短时间内java8 还是主流版本。当然，如果从java8基础上升级，几乎可以确定目标就是java11。 同时也要明确一个问题，现在java的版本升级周期与前些年相比速度快了太多，对于应用开发者来说没必要每一个小版本都去花时间研究，比如这些过渡版本：java9、java10、java12、java13（...
支持Java 8
最佳 Java 编程
06-14 190
尽管Java到目前为止已经发布了版本13，但是有许多生产安装都与Java 8一起运行。作为专家，即使是最近几天，我也多次开发Java 8代码，我必须为这不是Java 6而感到高兴。另一方面，作为开放源代码开发人员，我可以自由使用Java 11、12甚至13开发Java代码。 确实如此。 但是，另一方面，我希望使用我的代码。 开发诸如License3j或Java :: Geci之类的工具，...
Java 11 新特性介绍
weixin_30478757的博客
05-02 2645
Java 11 已于 2018 年 9 月 25 日正式发布，之前在Java 10 新特性介绍中介绍过，为了加快的版本迭代、跟进社区反馈，Java 的版本发布周期调整为每六个月一次——即每半年发布一个大版本，每个季度发布一个中间特性版本，并且做出不会跳票的承诺。通过这样的方式，Java 开发团队能够将一些重要特性尽早的合并到 Java Release 版本中，以便快速得到开发者的反馈，避免出现类...
Java流程控制：嵌套循环详解
"Java流程控制，包括嵌套循环和if-else条件结构" 在Java编程中，流程控制是程序设计的基础部分，它决定了程序的执行顺序。本资源主要讲解了嵌套循环和if-else条件结构，这些都是编写复杂逻辑的重要工具。 首先，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值