备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

使用RelProxy提高Java开发效率

2017-08-01 1106
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

RelProxy 旨在通过下列两种方式提高开发效率：

可以在生产环境下修改用户代码，而不需要重新加载整个应用。

提高开发效率，避免花费过多的时间加载应用且对性能不会有影响。

两个目标都要求在你的应用中增加一些 RelProxy 代码，注册成一种典型的监听、回调模式。这是一种“侵入”的方式。

如果你是一名Java 框架或独立 Java 通用服务模块的开发者，可以将 RelProxy Java 嵌入到你的框架中，这样能透明地为框架的终端用户提供代码自动加载功能，只需要进行一些必要的配置，而无需调用 RelProxy API。

对使用 Java 版的 RelProxy，有两种 API 可供调用：

JProxy 及其相关类：主要是静态方法

Java 脚本 API：基于接口

第二种方式更适合将 RelProxy 嵌入到你的 Java 框架中，这种方式是基于接口的，在你的 API 中无需暴露公共 RelProxy 类，因为在框架中会执行启动程序。我将使用比较简单的 API：JProxyScriptEngineFactory.create()。

JProxyScriptEngine 的功能与 Jproxy 相同，也就是说具有相同的方法。只是这种情况下，只需要使用接口。

一个简单的例子是演示如何嵌入 RelProxy 的最好方式。这个例子是 RelProxy 的示例仓库中包含的 RelProxyBuiltin（relproxy_builtin_ex 项目中）。它定义了两个监听器来实现注册用户端的代码，一个监听器显示选项（option），另一个执行选择的行为。

这个迷你框架和示例使用 NetBeans 和 Maven 开发完成。

有两个包：

com.innowhere.relproxy_builtin_ex ：迷你框架。子包 com.innowhere.relproxy_builtin_ex.impl 只包含一个非公共的类。

com.innowhere.relproxy_builtin_ex_main ：一个简单的使用示例。

迷你框架（公共类和接口）：

RelProxyBuiltinRoot.java

1

2

3

4

5

6

7

8

9

10

package com.innowhere.relproxy_builtin_ex;

import com.innowhere.relproxy_builtin_ex.impl.RelProxyBuiltinImpl;

public class RelProxyBuiltinRoot

{

    private final static RelProxyBuiltinImpl SINGLETON = new RelProxyBuiltinImpl();

    public static RelProxyBuiltin get()

    {

        return SINGLETON;

    }

}

RelProxyBuiltin.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

package com.innowhere.relproxy_builtin_ex;

import com.innowhere.relproxy.jproxy.JProxyScriptEngine;

import java.io.InputStream;

import java.io.PrintStream;

public interface RelProxyBuiltin

{

    public JProxyScriptEngine getJProxyScriptEngine();

    public void addOutputListener(OutputListener listener);

    public void removeOutputListener(OutputListener listener);

    public int getOutputListenerCount();

    public void addCommandListener(CommandListener listener);

    public void removeCommandListener(CommandListener listener);

    public int getCommandListenerCount();

    public void runLoop(InputStream in,PrintStream out);

}

OutputListener.java

1

2

3

4

5

6

package com.innowhere.relproxy_builtin_ex;

import java.io.PrintStream;

public interface OutputListener

{

    public void write(PrintStream out);

}

CommandListener.java

1

2

3

4

5

6

package com.innowhere.relproxy_builtin_ex;

import java.io.PrintStream;

public interface CommandListener

{

    public void execute(String command,String input,PrintStream out);

}

现在看一下实现细节，该类演示了怎样简单地内嵌 RelProxy：

RelProxyBuiltinImpl.java

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

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

package com.innowhere.relproxy_builtin_ex.impl;

import com.innowhere.relproxy.jproxy.JProxyScriptEngine;

import com.innowhere.relproxy.jproxy.JProxyScriptEngineFactory;

import com.innowhere.relproxy_builtin_ex.CommandListener;

import com.innowhere.relproxy_builtin_ex.OutputListener;

import com.innowhere.relproxy_builtin_ex.RelProxyBuiltin;

import java.io.InputStream;

import java.io.PrintStream;

import java.util.LinkedHashSet;

import java.util.Scanner;

public class RelProxyBuiltinImpl implements RelProxyBuiltin

{

    protected JProxyScriptEngine jProxyEngine = null;

    protected LinkedHashSet<OutputListener> outListeners = new LinkedHashSet<OutputListener>();

    protected LinkedHashSet<CommandListener>  commandListeners = new LinkedHashSet<CommandListener>();

    @Override

    public JProxyScriptEngine getJProxyScriptEngine()

    {

        if (jProxyEngine == null) jProxyEngine = (JProxyScriptEngine)JProxyScriptEngineFactory.create().getScriptEngine();

        return jProxyEngine;

    }

    public JProxyScriptEngine getJProxyScriptEngineIfConfigured()

    {

        if (jProxyEngine == null || !jProxyEngine.isEnabled())

            return null;

        return jProxyEngine;

    }

    @Override

    public void addOutputListener(OutputListener listener)

    {

        JProxyScriptEngine jProxy = getJProxyScriptEngineIfConfigured();

        if (jProxy != null)

        {

            listener = jProxy.create(listener,OutputListener.class);

        }

        outListeners.add(listener);

    }

    @Override

    public void removeOutputListener(OutputListener listener)

    {

        JProxyScriptEngine jProxy = getJProxyScriptEngineIfConfigured();

        if (jProxy != null)

        {

            listener = jProxy.create(listener,OutputListener.class);

        }

        outListeners.remove(listener);

    }

    @Override

    public int getOutputListenerCount()

    {

        return outListeners.size();

    }

    @Override

    public void addCommandListener(CommandListener listener)

    {

        JProxyScriptEngine jProxy = getJProxyScriptEngineIfConfigured();

        if (jProxy != null)

        {

            listener = jProxy.create(listener,CommandListener.class);

        }

        commandListeners.add(listener);

    }

    @Override

    public void removeCommandListener(CommandListener listener)

    {

        JProxyScriptEngine jProxy = getJProxyScriptEngineIfConfigured();

        if (jProxy != null)

        {

            listener = jProxy.create(listener,CommandListener.class);

        }

        commandListeners.remove(listener);

    }

    @Override

    public int getCommandListenerCount()

    {

        return commandListeners.size();

    }

    @Override

    public void runLoop(InputStream in,PrintStream out)

    {

        Scanner scanner = new Scanner(in);

        while(true)

        {

            out.print("Enter phrase:");

            String input = scanner.nextLine();

            out.println("Command list:");

            for(OutputListener listener : outListeners)

                listener.write(out);

            out.print("Enter command (or quit):");

            String command = scanner.nextLine();

            if ("quit".equals(command))

                break;

            for(CommandListener listener : commandListeners)

                listener.execute(command,input,out);

        }

    }

}

这三个方法足以解释怎样启动 RelProxy Java 引擎，怎样简单地使用指令监听器来注册热加载。

RelProxyBuiltinImpl.java (部分)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

@Override

  public JProxyScriptEngine getJProxyScriptEngine()

  {

      if (jProxyEngine == null) jProxyEngine = (JProxyScriptEngine)JProxyScriptEngineFactory.create().getScriptEngine();

      return jProxyEngine;

  }

  public JProxyScriptEngine getJProxyScriptEngineIfConfigured()

  {

      if (jProxyEngine == null || !jProxyEngine.isEnabled())

          return null;

      return jProxyEngine;

  }

  @Override

  public void addOutputListener(OutputListener listener)

  {

      JProxyScriptEngine jProxy = getJProxyScriptEngineIfConfigured();

      if (jProxy != null)

      {

          listener = jProxy.create(listener,OutputListener.class);

      }

      outListeners.add(listener);

  }

公共方法 RelProxyBuiltin.getJProxyScriptEngine() 必须在启动时执行，用于配置 RelProxy。如果没有配置，RelProxy 就不起作用。

请记住，通过 create(…) 创建的代理对象需要能正确的执行 hashCode() 方法和 equals(Object) 方法，监听器集合、监听记录依赖这两个方法来区别监听器对象。

这是基于控制台的示例代码（名称与 JUnit 类似，但确实不是 JUnit 的测试示例）：

Main.java

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

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

package com.innowhere.relproxy_builtin_ex_main;

import com.innowhere.relproxy.RelProxyOnReloadListener;

import com.innowhere.relproxy.jproxy.JProxy;

import com.innowhere.relproxy.jproxy.JProxyCompilerListener;

import com.innowhere.relproxy.jproxy.JProxyConfig;

import com.innowhere.relproxy.jproxy.JProxyDiagnosticsListener;

import com.innowhere.relproxy.jproxy.JProxyInputSourceFileExcludedListener;

import com.innowhere.relproxy.jproxy.JProxyScriptEngine;

import com.innowhere.relproxy_builtin_ex.CommandListener;

import com.innowhere.relproxy_builtin_ex.RelProxyBuiltin;

import com.innowhere.relproxy_builtin_ex.RelProxyBuiltinRoot;

import java.io.File;

import java.lang.reflect.Method;

import java.net.URL;

import java.util.Arrays;

import java.util.List;

import javax.tools.Diagnostic;

import javax.tools.DiagnosticCollector;

import javax.tools.JavaFileObject;

public class Main

{

    public static void main(String[] args) throws Exception

    {

        new Main();

    }

    public Main()

    {

        // Note: NetBeans Console window works bad (no input) with Maven Test tasks http://stackoverflow.com/questions/3035351/broken-console-in-maven-project-using-netbeans

        // this is why is not a really JUnit test.

        setUp();

        try

        {

            mainTest();

        }

        finally

        {

            tearDown();

        }

        System.exit(0);

    }

    public void setUp()

    {

        URL res = this.getClass().getResource("/"); // .../target/classes/

        // Use example of RelProxy in development time:

        String inputPath = res.getFile() + "/../../src/main/java/";

        if (new File(inputPath).exists())

        {

            System.out.println("RelProxy to be enabled, development mode detected");

        }

        else

        {

            System.out.println("RelProxy disabled, production mode detected");

            return;

        }

        JProxyInputSourceFileExcludedListener excludedListener = new JProxyInputSourceFileExcludedListener()

        {

            @Override

            public boolean isExcluded(File file, File rootFolderOfSources)

            {

                String absPath = file.getAbsolutePath();

                if (file.isDirectory())

                {

                    return absPath.endsWith(File.separatorChar + "relproxy_builtin_ex");

                }

                else

                {

                    return absPath.endsWith(File.separatorChar + Main.class.getSimpleName() + ".java");

                }

            }

        };

        String classFolder = null; // Optional

        Iterable<String> compilationOptions = Arrays.asList(new String[]{"-source","1.6","-target","1.6"});

        long scanPeriod = 1000;

        RelProxyOnReloadListener proxyListener = new RelProxyOnReloadListener() {

            @Override

            public void onReload(Object objOld, Object objNew, Object proxy, Method method, Object[] args) {

                System.out.println("Reloaded " + objNew + " Calling method: " + method);

            }

        };

        JProxyCompilerListener compilerListener = new JProxyCompilerListener(){

            @Override

            public void beforeCompile(File file)

            {

                System.out.println("Before compile: " + file);

            }

            @Override

            public void afterCompile(File file)

            {

                System.out.println("After compile: " + file);

            }

        };

        JProxyDiagnosticsListener diagnosticsListener = new JProxyDiagnosticsListener()

        {

            @Override

            public void onDiagnostics(DiagnosticCollector<JavaFileObject> diagnostics)

            {

                List<Diagnostic<? extends JavaFileObject>> diagList = diagnostics.getDiagnostics();

                int i = 1;

                for (Diagnostic diagnostic : diagList)

                {

                   System.err.println("Diagnostic " + i);

                   System.err.println("  code: " + diagnostic.getCode());

                   System.err.println("  kind: " + diagnostic.getKind());

                   System.err.println("  line number: " + diagnostic.getLineNumber());

                   System.err.println("  column number: " + diagnostic.getColumnNumber());

                   System.err.println("  start position: " + diagnostic.getStartPosition());

                   System.err.println("  position: " + diagnostic.getPosition());

                   System.err.println("  end position: " + diagnostic.getEndPosition());

                   System.err.println("  source: " + diagnostic.getSource());

                   System.err.println("  message: " + diagnostic.getMessage(null));

                   i++;

                }

            }

        };

        RelProxyBuiltin rpbRoot = RelProxyBuiltinRoot.get();

        JProxyScriptEngine engine = rpbRoot.getJProxyScriptEngine();

        JProxyConfig jpConfig = JProxy.createJProxyConfig();

        jpConfig.setEnabled(true)

                .setRelProxyOnReloadListener(proxyListener)

                .setInputPath(inputPath)

                .setJProxyInputSourceFileExcludedListener(excludedListener)

                .setScanPeriod(scanPeriod)

                .setClassFolder(classFolder)

                .setCompilationOptions(compilationOptions)

                .setJProxyCompilerListener(compilerListener)

                .setJProxyDiagnosticsListener(diagnosticsListener);

        engine.init(jpConfig);

        System.out.println("RelProxy running");

    }

    public void tearDown()

    {

        RelProxyBuiltin rpbRoot = RelProxyBuiltinRoot.get();

        JProxyScriptEngine engine = rpbRoot.getJProxyScriptEngine();

        engine.stop();

        System.out.println("RelProxy stopped");

    }

    public void mainTest()

    {

        RelProxyBuiltin rpbRoot = RelProxyBuiltinRoot.get();

        TestListener listener = new TestListener();

        rpbRoot.addOutputListener(listener);

        assertTrue(rpbRoot.getOutputListenerCount() == 1);

        rpbRoot.removeOutputListener(listener);

        assertTrue(rpbRoot.getOutputListenerCount() == 0);

        rpbRoot.addOutputListener(listener);

        CommandListener commandListener = listener.getCommandListener();

        rpbRoot.addCommandListener(commandListener);

        assertTrue(rpbRoot.getCommandListenerCount() == 1);

        rpbRoot.removeCommandListener(commandListener);

        assertTrue(rpbRoot.getCommandListenerCount() == 0);

        rpbRoot.addCommandListener(commandListener);

        rpbRoot.runLoop(System.in,System.out);

    }

    private static void assertTrue(boolean res)

    {

        if (!res) throw new RuntimeException("Unexpected Error");

    }

}

看一下这段代码：

Main.java （部分）

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

26

27

28

URL res = this.getClass().getResource("/"); // .../target/classes/

       // Use example of RelProxy in development time:

       String inputPath = res.getFile() + "/../../src/main/java/";

       if (new File(inputPath).exists())

       {

           System.out.println("RelProxy to be enabled, development mode detected");

       }

       else

       {

           System.out.println("RelProxy disabled, production mode detected");

           return;

       }

       JProxyInputSourceFileExcludedListener excludedListener = new JProxyInputSourceFileExcludedListener()

       {

           @Override

           public boolean isExcluded(File file, File rootFolderOfSources)

           {

               String absPath = file.getAbsolutePath();

               if (file.isDirectory())

               {

                   return absPath.endsWith(File.separatorChar + "relproxy_builtin_ex");

               }

               else

               {

                   return absPath.endsWith(File.separatorChar + Main.class.getSimpleName() + ".java");

               }

           }

       };

我们获取并注册应用源代码的根目录，该代码“可能”会被重新加载。

我们需要排除框架代码，因为这显然不是用户的代码（不需要重新加载）。此外，还需要排除 Main.java 文件，该文件包含了测试代码，也不需要重新加载，只有 TestListener.java 类（与 Main.java 在同一文件夹下）需要（必需）重新加载。

最后 TestListener.java 类包含两个监听器，CommandListener 的实现采用匿名内部类的方式，主要目的是为了演示。

TestListener.java

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

26

27

28

29

package com.innowhere.relproxy_builtin_ex_main;

import com.innowhere.relproxy_builtin_ex.CommandListener;

import com.innowhere.relproxy_builtin_ex.OutputListener;

import java.io.PrintStream;

public class TestListener implements OutputListener

{

    @Override

    public void write(PrintStream out)

    {

        out.println("uppercase");

        out.println("lowercase");

    }

    public CommandListener getCommandListener()

    {

        return new CommandListener()

        {

            @Override

            public void execute(String command,String text,PrintStream out)

            {

                if ("uppercase".equals(command))

                    out.println(text.toUpperCase());

                else if ("lowercase".equals(command))

                    out.println(text.toLowerCase());

                else

                    out.println("Unknown command:" + command);

            }

        };

    }

}

先预定义可选项，然后执行 Main 类。为了校验 RelProxy 是否起作用，可以在不停止程序的运行的基础上增加一个新的可选项“same”。

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

26

@Override

    public void write(PrintStream out)

    {

        out.println("uppercase");

        out.println("lowercase");

        out.println("same");  // NEW

    }

    public CommandListener getCommandListener()

    {

        return new CommandListener()

        {

            @Override

            public void execute(String command,String text,PrintStream out)

            {

                if ("uppercase".equals(command))

                    out.println(text.toUpperCase());

                else if ("lowercase".equals(command))

                    out.println(text.toLowerCase());

                else if ("same".equals(command)) // NEW

                    out.println(text); // NEW

                else

                    out.println("Unknown command:" + command);

            }

        };

    }

}

下一篇文章中将处理包含当前“same”的行为，不需要停止控制台应用。

ItsNat web 框架可能是第一个使用 RelProxy 技术的应用（版本 v1.4）。

注意：使用 RelProxy 0.8.7 或更高的版本，这个版本在嵌入方式上做了改进。


来源：51CTO

文章标签：
Java
API
Maven
开发者
关键词：
Java开发
Java开发效率
行者武松
目录
相关文章
桃李春风一杯酒
|
22天前
|
监控 JavaScript 前端开发
《理解 WebSocket：Java Web 开发的实时通信技术》
【4月更文挑战第4天】WebSocket是Java Web实时通信的关键技术，提供双向持久连接，实现低延迟、高效率的实时交互。适用于聊天应用、在线游戏、数据监控和即时通知。开发涉及服务器端实现、客户端连接及数据协议定义，注意安全、错误处理、性能和兼容性。随着实时应用需求增加，WebSocket在Java Web开发中的地位将更加重要。
桃李春风一杯酒
54 5
whisper1
|
1月前
JavaWeb 开发之 ServletContext 的和使用
JavaWeb 开发之 ServletContext 的和使用
whisper1
23 1
L&ecirc;v&iuml;
|
2天前
|
设计模式 存储 前端开发
Java从入门到精通：2.2.1学习Java Web开发，了解Servlet和JSP技术，掌握MVC设计模式
Java从入门到精通：2.2.1学习Java Web开发，了解Servlet和JSP技术，掌握MVC设计模式
L&ecirc;v&iuml;
14 0
桃李春风一杯酒
|
7天前
|
IDE Java 数据库连接
使用 Java 进行桌面应用开发
【4月更文挑战第19天】Java 是一款广泛应用于企业级、网络和桌面应用开发的编程语言。其跨平台特性使Java程序能在不同操作系统上运行，而JDK提供了开发所需工具和库。使用Swing等GUI库构建用户界面，结合JDBC进行数据库操作，Socket实现网络通信。虽然面临性能和用户体验的挑战，但通过优化和选用合适的IDE，Java仍能开发出高效稳定的桌面应用。
桃李春风一杯酒
13 1
一百减一是零
|
8天前
|
前端开发 Java Go
开发语言详解（python、java、Go(Golong)。。。。）
开发语言详解（python、java、Go(Golong)。。。。）
一百减一是零
57 0
源码宝
|
8天前
|
人工智能 前端开发 Java
Java语言开发的AI智慧导诊系统源码springboot+redis 3D互联网智导诊系统源码
智慧导诊解决盲目就诊问题，减轻分诊工作压力。降低挂错号比例，优化就诊流程，有效提高线上线下医疗机构接诊效率。可通过人体画像选择症状部位，了解对应病症信息和推荐就医科室。
源码宝
148 10
爱笑的源码基地
|
8天前
|
Java 关系型数据库 MySQL
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例
UWB (ULTRA WIDE BAND, UWB) 技术是一种无线载波通讯技术，它不采用正弦载波，而是利用纳秒级的非正弦波窄脉冲传输数据，因此其所占的频谱范围很宽。一套UWB精确定位系统，最高定位精度可达10cm，具有高精度，高动态，高容量，低功耗的应用。
爱笑的源码基地
30 0
一套java+ spring boot与vue+ mysql技术开发的UWB高精度工厂人员定位全套系统源码有应用案例
蓝易云
|
15天前
|
运维 NoSQL 算法
Java开发-深入理解Redis Cluster的工作原理
综上所述，Redis Cluster通过数据分片、节点发现、主从复制、数据迁移、故障检测和客户端路由等机制，实现了一个分布式的、高可用的Redis解决方案。它允许数据分布在多个节点上，提供了自动故障转移和读写分离的功能，适用于需要大规模、高性能、高可用性的应用场景。
蓝易云
16 0
爱笑的源码基地
|
17天前
|
人工智能 小程序 Java
JAVA开发智慧学校系统源码+人脸电子班牌布局
智慧校园是通过利用物联网，大数据技术来改变师生和校园资源相互交互的方式，以便提高交互的明确性、灵活性和响应速度，从而实现智慧化服务和管理的校园模式。
爱笑的源码基地
24 0
龙大吉
|
20天前
|
安全 前端开发 Java
Java Web开发知识点学习总结
Java Web开发涉及Java基础、Servlet、JSP、数据库操作（SQL+JDBC）、MVC设计模式、Spring框架、Hibernate ORM、Web服务（SOAP&RESTful）、安全认证（HTTP Basic/Digest/OAuth）及性能优化（缓存、异步、负载均衡）。
龙大吉
18 3

热门文章

最新文章

  • 1
    Java中的多线程编程：概念、实现与性能优化
  • 2
    基于 java + Springboot + vue +mysql 大学生实习管理系统（含源码）
  • 3
    使用Java代码打印log日志
  • 4
    Java数据结构与算法-java数据结构与算法（二）
  • 5
    【JVM故障问题排查心得】「Java技术体系方向」Java虚拟机内存优化之虚拟机参数调优原理介绍（一）
  • 6
    深入理解Java并发编程：线程安全与性能优化
  • 7
    Java入门高频考查基础知识4（字节跳动面试题18题2.5万字参考答案）
  • 8
    开发语言详解（python、java、Go(Golong)。。。。）
  • 9
    《理解 WebSocket：Java Web 开发的实时通信技术》
  • 10
    java线程池讲解面试
  • 1
    Java中的集合框架：深入理解与应用
    19
  • 2
    Java并发编程：理解并使用Future和Callable接口
    17
  • 3
    性能工具之 Java 调试工具 JDB
    45
  • 4
    JAVA云HIS系统医院信息管理源码
    31
  • 5
    Java基于物联网技术的智慧工地云管理平台源码 依托丰富的设备接口标准库，快速接入工地现场各类型设备
    148
  • 6
    [Java基础]——JVM内存模型
    36
  • 7
    [Java基础]——类的生命周期
    13
  • 8
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    23
  • 9
    【java进阶】Java中线程的实现方式
    14
  • 10
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    17

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 基于函数计算快速搭建Zblog等传统应用框架
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）