一、线程组Java中ThreadGroup表示线程组，每个线程比如属于一个线程组，创建线程时，如果没有指定线程组，那么新创建的线程默认属于其父线程所在线程组。public class ThreadDemo { public static void main(String[] args) { Thread testThread = new Thread(() -> { System.out.println("测试线程组：" + Thread.currentThread().getThreadGroup().getName()); System.out.println("测试线程名：" + Thread.currentThread().getName()); }); testThread.start(); System.out.println("main线程名：" + Thread.currentThread().getName()); } }线程组管理其中的线程，线程组是一个标准的树状结构，这样涉及的原因是防止“上级”线程被“下级”线程引用而无法进行有效的GC回收。二、线程优先级Java中线程优先级是支持指定的，范围是1-10，但并不是所有操作系统都支持10级优先级，，Java只给操作系统一个优先级的参考量，线程在操作系统中最终的优先级还是有操作系统决定的。线程默认优先级是5，线程的执行顺序由调度程序来决定，通常情况下，高优先级的线程会比低优先级的线程有更高的机率得到执行。import java.util.stream.IntStream; public class ThreadDemo { public static void main(String[] args) { IntStream.range(1, 10).forEach(i -> { Thread thread = new Thread(() -> { System.out.println(String.format("当前线程名称%s,优先级%s", Thread.currentThread().getName(), Thread.currentThread().getPriority())); }); thread.setPriority(i); thread.start(); }); } }某次的输出结果当前线程名称Thread-5,优先级6 当前线程名称Thread-0,优先级1 当前线程名称Thread-1,优先级2 当前线程名称Thread-4,优先级5 当前线程名称Thread-7,优先级8 当前线程名称Thread-2,优先级3 当前线程名称Thread-8,优先级9 当前线程名称Thread-6,优先级7 当前线程名称Thread-3,优先级4Java提供⼀个线程调度器来监视和控制处于RUNNABLE状态的线程。线程的调度策略采⽤抢占式，优先级⾼的线程⽐优先级低的线程会有更⼤的⼏率优先执⾏。在优先级相同的情况下，按照“先到先得”的原则。每个Java程序都有⼀个默认的主线程，就是通过JVM启动的第⼀个线程main线程。线程组与线程都有优先级，当线程组内的线程优先级高于线程组的优先级时，系统会自动设置线程的优先级为线程组的优先级。public class ThreadDemo { static int i = 0; public static void main(String[] args) throws Exception { ThreadGroup threadGroup = new ThreadGroup("TestThreadGroup"); threadGroup.setMaxPriority(4); Thread thread = new Thread(threadGroup, () -> { System.out.println("测试线程优先级与线程组优先级"); }); thread.setPriority(6); System.out.println("线程实际优先级：" + thread.getPriority()); } }输出结果线程实际优先级：4三、守护线程如果某线程是守护线程，那如果所有的⾮守护线程结束，这个守护线程也会⾃动结束。守护线程优先级较低。⼀个线程默认是⾮守护线程，可以通过setDaemon(boolean on)来设置一个线程是否是守护线程。import java.util.stream.IntStream; public class ThreadDemo { static int i = 0; public static void main(String[] args) throws Exception { Thread thread = new Thread(() -> { while (true) { System.out.println("我还活着" + ++i); } }); thread.start(); System.out.println("main方法执行完成"); } }输出结果：main方法执行完成 我还活着1 我还活着2 ......引入thread线程默认不是守护线程，所以即使main线程结束后，thread线程也会一直循环下去。我们稍作稍作修改，把thread线程设置成非守护线程。import java.util.stream.IntStream; public class ThreadDemo { static int i = 0; public static void main(String[] args) throws Exception { Thread thread = new Thread(() -> { while (true) { System.out.println("我还活着" + ++i); } }); thread.setDaemon(true); thread.start(); //让main线程暂停10ms，防止守护线程未执行main线程就结束的情况 thread.sleep(10); System.out.println("main方法执行完成"); } }某次输出结果我还活着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 main方法执行完成 我还活着120 我还活着121 我还活着122 我还活着123 我还活着124可以看到main线程执行完成后，守护线程会自动关闭。
通常来讲，我们使用Runnable接口或者Thread类来创建一个新线程，但是他们有一个缺点，就是run方法没有返回值，如果我们需要开启线程后获得一个返回值，就可以使用Callable接口配合Future类来实现。一、Callable接口Callable⼀般是配合线程池⼯具ExecutorService来使⽤。ExecutorService可以使⽤submit⽅法来让⼀个Callable接⼝执⾏，它会返回⼀个Future，我们后续的程序可以通过这个Future的get⽅法得到结果。可以看一下下面的Demoimport java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class FutureDemo implements Callable<String> { @Override public String call() throws Exception { return "Hello,World"; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); FutureDemo futureDemo = new FutureDemo(); Future<String> tFuture = executorService.submit(futureDemo); try { System.out.println(tFuture.get()); } catch (Exception exception) { } } }运行后，控制台会输出Hello,World二、Future接口看一下Future接口的源代码public interface Future<V> { /** * 试图取消一个线程的执行，但是不一定能成功，因为任务可能已完成或已取消或其他因素不能取消 * * @param 是否允许打断正在执行的任务 * @return 是否取消成功 */ boolean cancel(boolean mayInterruptIfRunning); /** * 获取线程是否已取消 * * @return 线程完成前被取消返回true */ boolean isCancelled(); /** * 获取线程是否已完成 * * 如果线程异常、被终止或者取消，都会返回true * * @return 线程完成返回true */ boolean isDone(); /** * 获取线程返回值 * * @return 线程返回结果 */ V get() throws InterruptedException, ExecutionException; /** * 在给定时间内获取返回值，如果超时未获取到返回超时异常 * * @param 获取结果最大等待时间 * @param 时间计量单位 * @return 结果 */ V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }下面通过实际代码看一下Future接口的基本用法。修改上面代码如下import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; public class FutureDemo implements Callable<String> { @Override public String call() throws Exception { return "Hello,World"; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); FutureDemo futureDemo = new FutureDemo(); Future<String> tFuture = executorService.submit(futureDemo); // 判断线程是否完成 System.out.println("线程是否完成：" + tFuture.isDone()); // 判断线程是否取消 System.out.println("线程是否取消：" + tFuture.isCancelled()); try { System.out.println(tFuture.get()); // 判断线程是否完成 System.out.println("线程是否完成：" + tFuture.isDone()); // 判断线程是否取消 System.out.println("线程是否取消：" + tFuture.isCancelled()); } catch (Exception exception) { } } } 输出结果线程是否完成：false 线程是否取消：false Hello,World 线程是否完成：true 线程是否取消：false可以看到，在获取到结果前，线程是未完成、未取消的，获取到结果后，线程正常结束，此时线程是已完成、未取消的。下面代码继续修改，我们在获取结果之前先取消，因为线程可能来不及取消已经完成，所以我们加个让call方法睡眠1s。import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.CancellationException; public class FutureDemo implements Callable<String> { @Override public String call() throws Exception { Thread.sleep(1000); return "Hello,World"; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); FutureDemo futureDemo = new FutureDemo(); Future<String> tFuture = executorService.submit(futureDemo); // 判断线程是否完成 System.out.println("线程是否完成：" + tFuture.isDone()); // 判断线程是否取消 System.out.println("线程是否取消：" + tFuture.isCancelled()); try { // 试图取消线程 boolean isCancelled = tFuture.cancel(true); System.out.println("任务是否取消成功:" + isCancelled); // 判断线程是否完成 System.out.println("线程是否完成：" + tFuture.isDone()); // 判断线程是否取消 System.out.println("线程是否取消：" + tFuture.isCancelled()); // get的时候需要判断线程状态 System.out.println(tFuture.get()); } catch (CancellationException cancellationException) { System.out.println("线程已经被取消"); } catch (Exception exception) { exception.printStackTrace(); } } } 输出结果线程是否完成：false 线程是否取消：false 任务是否取消成功:true 线程是否完成：true 线程是否取消：true 线程已经被取消可以看到，线程已经取消成功，线程取消成功后，如果还是调用get方法，会抛出CancellationException异常，并且线程取消成功后，isDone方法也会返回true，代表线程已经完成。最后一个方法，我们看一下增加get的重载方法。import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.CancellationException; public class FutureDemo implements Callable<String> { @Override public String call() throws Exception { Thread.sleep(1000); return "Hello,World"; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); FutureDemo futureDemo = new FutureDemo(); Future<String> tFuture = executorService.submit(futureDemo); try { // get方法如果0.5秒内未获取到结果就抛出超时异常 System.out.println(tFuture.get((long)0.5, TimeUnit.SECONDS)); } catch (TimeoutException timeoutException) { System.out.println("超过0.5s未获取到结果"); } catch (Exception exception) { exception.printStackTrace(); } } } 输出结果超过0.5s未获取到结果三、FutureTask类FutureTask是Java自带的Future接口的实现类。FutureTask是实现的RunnableFuture接⼝，⽽RunnableFuture接⼝同时继承了Runnable接⼝和`Future接⼝。import java.util.concurrent.Callable; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; import java.util.concurrent.FutureTask; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; import java.util.concurrent.CancellationException; public class FutureDemo implements Callable<String> { @Override public String call() throws Exception { return "Hello,World"; } public static void main(String[] args) { ExecutorService executorService = Executors.newCachedThreadPool(); FutureDemo futureDemo = new FutureDemo(); FutureTask<String> futureTask = new FutureTask<>(futureDemo); executorService.submit(futureTask); try { System.out.println(futureTask.get()); }catch (Exception exception) { exception.printStackTrace(); } } } 输出结果：Hello,World文章摘抄自《深入浅出Java多线程.pdf》并对内容进行完善。
volatile是Java中的关键字，用于修饰变量，被volatile修饰的变量可以确保线程对这个变量的读写都是直接从主内存在中进行的。我们先来看下面一段代码public class Volatile { private boolean ready; public void setReady(boolean ready) { this.ready = ready; } public boolean getReady() { return this.ready; } public static void main(String[] args) throws Exception { Volatile volatile1 = new Volatile(); new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException exception) { exception.printStackTrace(); } volatile1.setReady(true); System.out.println("设置ready值为true"); }).start(); new Thread(() -> { while (!volatile1.getReady()) { } System.out.println("检测到ready变成" + volatile1.getReady()); }).start(); } }运行这段代码，我们查看控制台，可以看到虽然我们在第一个线程中将ready值设置成了true，但是第二个线程中，while仍然进入了一个死循环。这是因为在两个线程中，ready的值被隔离了，所以我们在第一个线程中修改的ready值在第二个线程中是获取不到的。这个时候，我们可以给ready变量加上volatile关键字进行修饰，修改后代码如下public class Volatile { private volatile boolean ready; public void setReady(boolean ready) { this.ready = ready; } public boolean getReady() { return this.ready; } public static void main(String[] args) throws Exception { Volatile volatile1 = new Volatile(); new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException exception) { exception.printStackTrace(); } volatile1.setReady(true); System.out.println("设置ready值为true"); }).start(); new Thread(() -> { while (!volatile1.getReady()) { } System.out.println("检测到ready变成" + volatile1.getReady()); }).start(); } }再次运行代码，可以发现第一个线程中的内容正常输出了，这就是volatile关键字的作用，一个线程中修改被volatile修饰的变量，另外一个变量能立即看到修改后的值。volatile关键字有两个作用：可见性及有序性。可见性当一个线程修改了被volatile修饰的变量的值，其他线程能够立刻看到修改后的值。这是因为被volatile修饰的变量不会被缓存到寄存器或其他处理器不可见的地方，因此保证了每次读取volatile变量都会从住内存中读取最新的值。有序性被volatile修饰的变量的读写具有一定的有序性，也就是禁止了指令重排序优化，这就意味着，在一个线程中，对被volatile修饰的变量的写操作一定发生在后续对这个变量的读操作之前。
在Java 1.8及后续的版本中，我们有三种（也可以说是两种）方法开启线程。继承Thread类实现Runnable接口使用Java 8的函数式编程其中1和3的方式没有什么歧义，我们重点说一下Runnable接口。其实标题说Runnable接口的run()方法和start()方法是不准确的，严格来讲，应该是Runnable接口的run()方法和实现Runnable接口的实例的start()。先说一下结论，start()方法来启动线程，真正实现了多线程运行。这时无需等待run方法体代码执行完毕，可以直接继续执行下面的代码；而run()方法当作普通方法的方式调用。程序还是要顺序执行，要等待run方法体执行完毕后，才可继续执行下面的代码，程序中只有主线程——这一个线程，其程序执行路径还是只有一条，这样就没有达到写线程的目的。我们可以通过下面代码进行验证。public class Demo { static class Runner1 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程 public void run() { for (int i = 0; i < 10; i++) { System.out.println("进入Runner1运行状态——————————" + i); } } } static class Runner2 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程 public void run() { for (int i = 0; i < 10; i++) { System.out.println("进入Runner2运行状态==========" + i); } } } public static void main(String[] args) { Runner1 runner1 = new Runner1(); Runner2 runner2 = new Runner2(); runner1.run(); runner2.run(); // new Thread(runner1).start(); // new Thread(runner2).start(); } }看一下控制台输出内容，程序是先执行完runner1之后才执行的runner2方法，系统并没有给线程排队，相当于runner1和runner2是顺序执行的。我们修改上面的代码，改成start()方法执行public class Demo { static class Runner1 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程 public void run() { for (int i = 0; i < 10; i++) { System.out.println("进入Runner1运行状态——————————" + i); } } } static class Runner2 implements Runnable { // 实现了Runnable接口，jdk就知道这个类是一个线程 public void run() { for (int i = 0; i < 10; i++) { System.out.println("进入Runner2运行状态==========" + i); } } } public static void main(String[] args) { Runner1 runner1 = new Runner1(); Runner2 runner2 = new Runner2(); // runner1.run(); // runner2.run(); new Thread(runner1).start(); new Thread(runner2).start(); } }再次查看控制台可以看到runner1和runner2是交替执行的，也就证明了，此时正确的开启了线程。
VisualVM是功能最强大的虚拟机运行监视和故障处理程序之一，曾经在很长一段时间内是Oracle官方助理发展的虚拟机故障处理工具。VisualVM的性能分析功能，比起JProfiler等专业收费工具也不遑多让，相比于第三方的功能，VisualVM还有一个很大的优点：不需要被监视的程序基于特殊的Agent去运行，因此它的通用性很强，对应用程序实际性能影响也比较小，使得它可以直接应用于生产环境。在这个注重颜值的时代，相较于JProfiler，可能界面比较丑陋是最大的缺点了吧。在强大的插件加持下，VisualVM可以实现包括但不限于以下的功能：显示虚拟机进程以及进程的配置、环境信息显示应用程序的处理器、垃圾收集、堆、方法区及线程信息dump以及分析堆转储快照方法级的应用程序性能分析，找出被调用最多、运行时间最长的方法壹、安装插件VisualVM插件可以直接在线安装，依次点击【tools】- 【plugins】勾选需要安装的插件，点击【install】即可进行安装。贰、生成、浏览堆转储快照生成和浏览堆转储快照可能是日常开发过程中分析性能最常见的操作，下面介绍下在visualVM中如何生成或者分析堆转储快照。一、生成堆转储快照我们运行一个程序后，在visualVM左侧Local下，会自动加载对应的进程信息。比如我这里的JHSDB_TestCae，我们下面都以这个为例进行说明。可以通过以下两种方式之一生成堆转储快照选择应用程序，点击右键，然后选择【Heap Dump】双击应用程序，在打开的页面中，选择【Monitor】，然后选择【Heap Dump】快照存储后会自动打开。二、打开堆转储快照如果是别人发过来的快照文件，可以点击左上角的文件图标打开。Overview页签显示的是一些基本信息，包括pid、Java版本、虚拟机参数、环境参数等信息。Monitor页签是图标信息显示的CPU、堆、元空间、类及线程等信息。Threads页签显示的是线程信息Sampler页签以一定的时间间隔对CPU、内存进行采样，可检查出占用CPU时间较多或占用内存空间较大的线程，有助于性能调优。对CPU采样时，该页提供CPU样例(CPU samples)和线程CPU时间(Thread CPU time)两个子页签，前者可用于分析调用链上的方法耗时，后者可用于比较线程CPU耗时。profiler是性能分析页签，因为性能分析对程序运行性能影响较大，生产环境不建议使用。叁、常见插件介绍上面所过，VisualVM是支持插件的，下面我们介绍几款常用的插件。一、BTrace动态日志跟踪BTrace允许在不中断目标程序的前提下，通过HotSpot虚拟机的Instrument功能动态加入原本并不存在的调试代码。在插件页面，选择BTrace Workbench，然后安装我们创建一段输出固定内容的死循环并运行package cc.lisen.test; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * description: * * @author: lisen * @Blog：lisen.cc * @DateTime: 2025-04-20 20:34 */ public class BTraceTest { public String sayHello(String name) { return "Hello " + name; } public static void main(String[] args) throws IOException { while (true) { BTraceTest bTraceTest = new BTraceTest(); BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); System.out.println(bTraceTest.sayHello(reader.readLine())); } } }打开VisualVM，找到我们的程序，点击右键选择【Trace Application】，然后输入以下脚本/* BTrace Script Template */ import org.openjdk.btrace.core.annotations.*; import static org.openjdk.btrace.core.BTraceUtils.*; @BTrace(unsafe=true) public class TracingScript { @OnMethod( clazz="cc.lisen.test.BTraceTest", method="sayHello", location=@Location(Kind.RETURN) ) public static void func(@Self cc.lisen.test.BTraceTest instance,String test,@Return String result) { System.out.println("调用堆栈:"); jstack(); } }
jstack是用于生成java虚拟机当前时刻的线程快照。线程快照是当前java虚拟机内存每一条线程正在执行的方法堆栈的集合，生成线程快照的主要目的是定位线程出现长时间停顿的原因。一、分析CPU占用高的问题在实际项目开发过程中，CPU占用异常是经常遇到的问题，当遇到CPU异常时，我们可以借助jstack进行问题排查。下面我们通过模拟，刨析一下整个问题分析过程。模拟代码在下面的代码中，我们写了一个死循环，模拟CPU占用过高问题。public class ThreadMain { private static ExecutorService executorService = Executors.newFixedThreadPool(5); public static void main(String[] args) { Task task1 = new Task(); Task task2 = new Task(); executorService.execute(task1); executorService.execute(task2); } public static Object lock = new Object(); static class Task implements Runnable { public void run() { synchronized (lock) { long sum = 0L; while (true) { sum += 1; } } } } }查询CPU占用高的进程在Linux服务器，我们通过top命令，可以查看CPU信息，默认按照由高到低显示。输入top命令，查询进程信息。top可以看到，目前占用最高的进程ID是9420查询对应线程在上面，我们已经查询到9420进程，我们可以进一步分析，9420进程内到底是哪个线程CPU占用最高。输入一下命令，可以查看线程信息top Hp 9420可以看到目前占用CPU最高的线程是9445线程转换我们通过top命令查询到的9445线程ID是10进制的，但是jstack展示的线程是16进制的，因此我们需要将10进制的9445转成16进制，也就是0x24e5通过jstack查询线程快照输入一下命令jstack 9420{alert type="info"}jstack后的vmid就是进程ID{/alert}jstack输出信息的nid就是16进制的线程id，我们找到nid是0x24e5线程，可以定位到具体代码位置 at ThreadMain$Task.run(ThreadMain.java:30)，也就是ThreadMain.java的第30行。二、分析线程死锁问题模拟代码我们通过下面的代码，模拟线程死锁问题public class ThreadMain { private final static Object lockA = new Object(); private final static Object lockB = new Object(); public static void main(String[] args) { new Thread(() -> { synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获得了锁LockA"); try { Thread.sleep(1000); } catch (InterruptedException e) { try { throw new RuntimeException(e); } catch (RuntimeException ex) { throw new RuntimeException(ex); } } synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获得了锁LockB"); } } }).start(); new Thread(() -> { synchronized (lockB) { System.out.println(Thread.currentThread().getName() + "获得了锁LockB"); try { Thread.sleep(1000); } catch (InterruptedException e) { try { throw new RuntimeException(e); } catch (RuntimeException ex) { throw new RuntimeException(ex); } } synchronized (lockA) { System.out.println(Thread.currentThread().getName() + "获得了锁LockA"); } } }).start(); } }查询VMID我们通过jps命令，可以查询虚拟机进程IDjps -l可以看到，我们当前VMID是18395查询线程信息同样通过jstack命令可以查询进程信息。jstack 18395重点关注状态时BLOCKED的线程，我们可以看到Thread-1跟Thread-1目前都是BLOCKED状态，Thread-1目前锁定了<0x0000000782539600>并且正在等待<0x00000007825395f0>,而Thread-0正好相反，Thread-0锁定了<0x00000007825395f0>并且正在等待<0x0000000782539600>，这就导致两个线程相互锁定。当然，我们也可以看到两个线程异常发生的位置。
当系统发生内存溢出时，我们一般的处理方式都是通过抓取内存堆转储快照的形式进行分析，本文我们介绍几种日常常用的dump文件分析工具。准备工作我们通过-XX:+HeapDumpOnOutOfMemoryError参数让虚拟机在出现内存溢出时Dump出当前的内存堆转储快照，然后对Dump出的文件进行分析。示例代码如下import java.util.ArrayList; import java.util.List; public class HeapDump { static class HeapDumpObject { } public static void main(String[] args) { List<HeapDumpObject> heapDumpObjectList = new ArrayList<>(); while (true) { heapDumpObjectList.add(new HeapDumpObject()); } } }我们通过命令运行程序javac HeapDump.java java -Xms20m -Xmx20m -XX:+HeapDumpOnOutOfMemoryError HeapDump此时程序会在程序运行目录下生成.hprof格式的dump文件，我们可以针对此文件进行分析，查找内存泄漏对象的引用路径，并定位到代码具体位置。工具一：JVisualVMJVisualVM是JDK自带的dump，目前在JDK中已经没有预置此工具了，我们可以通过 官网进行下载。点击左上角，可以加载我们的dump文件可以切换摘要、线程等页签，查看不同的跟踪信息。工具二：IntelliJ Idea自带的分析器依次打开【视图】-【工具窗口】- 【分析器】点击【打开快照】，选择我们上方生成的.hprof文件可以分析最大对象以及定位我们异常发生的位置。工具三：MATMAT全称Memory Analyzer，是eclipse出品的一款独立的内存分析工具，可以在 官网下载。{message type="success" content="下载时，注意选择镜像位置，默认日本节点较慢"/}打开软件后，选择[Open a Heap Dump]可以查看对象占用空间等信息，也可以定位具体代码位置工具三：JProfilerJProfiler 是一款强大的性能分析工具，能够深入分析 Java 应用程序的 CPU 使用情况、内存消耗、线程状态和数据库查询，从而帮助快速定位性能瓶颈。打开JProfiler后，点击左上角【会话】-【打开快照】，可以选择我们本地的dump文件。双击占用最大的类，然后引用选择【传入引用】在【引用】页签，选择点击【显示更多】，可以查看异常代码的位置。
在Java或者Spring Boot日常开发过程中，因为Java的自动垃圾回收机制，我们可能很少关注JVM的信息，面临性能问题时，我们可能也会更多的借助JProfiler等第三方工具进行问题分析。比如我们需要做一个程序运行健康监控功能，我们可能就需要获取Jvm的信息，下面我们就看一下如何在Java中获取Jvm信息。首先我们定义两个公共方法，分别是用来将毫秒转换成时分秒，另外一个方法是将时间戳转换成时分秒毫秒。/** * 毫秒转换成时分秒 * * @param uptime 毫秒 * @return 时分秒 */ protected static String toDuration(double uptime) { NumberFormat fmtI = new DecimalFormat("###,###", new DecimalFormatSymbols(Locale.ENGLISH)); NumberFormat fmtD = new DecimalFormat("###,##0.000", new DecimalFormatSymbols(Locale.ENGLISH)); uptime /= 1000; if (uptime < 60) { return fmtD.format(uptime) + " 秒"; } uptime /= 60; if (uptime < 60) { long minutes = (long) uptime; return fmtI.format(minutes) + "分"; } uptime /= 60; if (uptime < 24) { long hours = (long) uptime; long minutes = (long)((uptime - hours) * 60); String s = fmtI.format(hours) + "时"; if (minutes != 0) { s += " " + fmtI.format(minutes) + "分"; } return s; } uptime /= 24; long days = (long) uptime; long hours = (long)((uptime - days) * 24); String s = fmtI.format(days) + "天"; if (hours != 0) { s += " " + fmtI.format(hours) + "时"; } return s; } /** * 时间戳钻日期 * * @param timeStamp 时间戳 * @return 日期 */ protected static String timeStamp2Date(long timeStamp) { SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", Locale.ENGLISH); return simpleDateFormat.format(timeStamp); }{mtitle title="获取Jvm基本信息"/}可以获取jvm的名称、jvm版本、jvm制造商、java版本、jvm启动时间、jvm运行时间等信息RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean(); System.out.printf("jvm名称：%s %n", runtimeMXBean.getVmName()); System.out.printf("jvm版本：%s %n", runtimeMXBean.getVmVersion()); System.out.printf("jvm制造商：%s %n", runtimeMXBean.getVmVendor()); System.out.printf("java版本：%s %n", System.getProperty("java.version")); System.out.printf("jvm启动时间：%s %n", timeStamp2Date(runtimeMXBean.getStartTime())); System.out.printf("jvm运行时间：%s %n", toDuration(runtimeMXBean.getUptime()));{mtitle title="获取编译信息"/}可以获取编译器名称、编译耗时及是否支持及时编译器编译监控。CompilationMXBean compilationMXBean = ManagementFactory.getCompilationMXBean(); System.out.printf("编译器名称：%s %n", compilationMXBean.getName()); System.out.printf("编译耗时：%s %n", toDuration(compilationMXBean.getTotalCompilationTime())); System.out.printf("是否支持及时编译器编译监控：%s %n", compilationMXBean.isCompilationTimeMonitoringSupported());{mtitle title="获取线程信息"/}可以获取总线程数、守护进程线程数、峰值线程数、Java虚拟机启动后创建并启动的线程总数、是否支持测量当前线程的CPU时间等信息。ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean(); System.out.printf("总线程数(守护+非守护)：%s %n", threadMXBean.getThreadCount()); System.out.printf("守护进程线程数：%s %n", threadMXBean.getDaemonThreadCount()); System.out.printf("峰值线程数：%s %n", threadMXBean.getPeakThreadCount()); System.out.printf("Java虚拟机启动后创建并启动的线程总数：%s %n", threadMXBean.getTotalStartedThreadCount()); System.out.printf("是否支持测量当前线程的CPU时间：%s %n", threadMXBean.isCurrentThreadCpuTimeSupported()); System.out.printf("当前线程的总CPU时间：%s %n", threadMXBean.getCurrentThreadCpuTime()); System.out.printf("当前线程在用户模式中执行的CPU时间：%s %n", threadMXBean.getCurrentThreadUserTime()); {mtitle title="堆内存使用情况"/}可以获取初始化堆内存、已使用堆内存、可使用堆内存、最大堆内存等信息MemoryUsage heapMemoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(); System.out.printf("初始化堆内存：%sm %n", heapMemoryUsage.getInit() / 1024 / 1024); System.out.printf("已使用堆内存：%sm %n", heapMemoryUsage.getUsed() / 1024 / 1024); System.out.printf("可使用堆内存：%sm %n", heapMemoryUsage.getCommitted() / 1024 / 1024); System.out.printf("最大堆内存：%sm %n", heapMemoryUsage.getMax() / 1024 / 1024); 为了方便查询数据，我们可以手工编译、运行代码javac JvmInfo.java java -Xmx20m JvmInfo{mtitle title="非堆内存使用情况"/}也可以获取非堆内存，也就是永久代的信息。需要注意，JDK1.7之后已经废弃了永久代的概念，使用元空间进行替代MemoryUsage noHeapMemoryUsage = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage(); System.out.printf("初始化非堆内存：%sm %n", noHeapMemoryUsage.getInit() / 1024 / 1024); System.out.printf("已使用非堆内存：%sm %n", noHeapMemoryUsage.getUsed() / 1024 / 1024); System.out.printf("可使用非堆内存：%sm %n", noHeapMemoryUsage.getCommitted() / 1024 / 1024); System.out.printf("最大非堆内存：%sm %n", noHeapMemoryUsage.getMax() / 1024 / 1024); {mtitle title="系统概况"/}可以获取操作系统名称、操作系统版本、处理器数量、系统平均负载、电脑架构等信息OperatingSystemMXBean operatingSystemMXBean = ManagementFactory.getOperatingSystemMXBean(); System.out.printf("操作系统名称：%s %n", operatingSystemMXBean.getName()); System.out.printf("操作系统版本：%s %n", operatingSystemMXBean.getVersion()); System.out.printf("可用处理器数量%s %n", operatingSystemMXBean.getAvailableProcessors()); System.out.printf("系统平均负载：%f %n", operatingSystemMXBean.getSystemLoadAverage()); System.out.printf("电脑架构：%s %n", operatingSystemMXBean.getArch());{mtitle title="类加载情况"/}可获取当前加载类数量、未加载类数量、总加载类数量ClassLoadingMXBean classLoadingMXBean = ManagementFactory.getClassLoadingMXBean(); System.out.printf("当前加载类数量%s %n", classLoadingMXBean.getLoadedClassCount()); System.out.printf("未加载类数量%s %n", classLoadingMXBean.getUnloadedClassCount()); System.out.printf("总加载类数量%s %n", classLoadingMXBean.getTotalLoadedClassCount()); 也可以获取内存池对象public static void main(String[] args) { List < MemoryPoolMXBean > memoryPoolMXBeanList = ManagementFactory.getMemoryPoolMXBeans(); for (MemoryPoolMXBean memoryMXBean: memoryPoolMXBeanList) { final String kind = memoryMXBean.getType().name(); final MemoryUsage usage = memoryMXBean.getUsage(); System.out.println( "内存模型： " + getKindName(kind) + ", 内存空间名称： " + getPoolName(memoryMXBean.getName()) + ", jvm." + memoryMXBean.getName() + ".init(初始化):" + bytesToMB(usage.getInit())); System.out.println( "内存模型： " + getKindName(kind) + ", 内存空间名称： " + getPoolName(memoryMXBean.getName()) + ", jvm." + memoryMXBean.getName() + ".used(已使用): " + bytesToMB(usage.getUsed())); System.out.println( "内存模型： " + getKindName(kind) + ", 内存空间名称： " + getPoolName(memoryMXBean.getName()) + ", jvm." + memoryMXBean.getName() + ".committed(可使用):" + bytesToMB(usage.getCommitted())); System.out.println( "内存模型： " + getKindName(kind) + ", 内存空间名称： " + getPoolName(memoryMXBean.getName()) + ", jvm." + memoryMXBean.getName() + ".max(最大):" + bytesToMB(usage.getMax())); } } protected static String getKindName(String kind) { if ("NON_HEAP".equals(kind)) { return "NON_HEAP(非堆内存)"; } else { return "HEAP(堆内存)"; } } protected static String getPoolName(String poolName) { switch (poolName) { case "Code Cache": return poolName + "(代码缓存区)"; case "Metaspace": return poolName + "(元空间)"; case "Compressed Class Space": return poolName + "(类指针压缩空间)"; case "PS Eden Space": return poolName + "(伊甸园区)"; case "PS Survivor Space": return poolName + "(幸存者区)"; case "PS Old Gen": return poolName + "(老年代)"; default: return poolName; } } protected static String bytesToMB(long bytes) { return (bytes / 1024 / 1024) + " MB"; }
{message type="info" content="VSCode简介"/} 大名鼎鼎的VS Code不用过多介绍吧。VS Code全称Visual Studio Code，是由微软开发的一款免费、开源、跨平台的代码编辑器，支持Windows、macOS和Linux系统。它以其轻量级、高性能和丰富的扩展生态广受开发者欢迎，适用于多种编程语言和开发场景。 如果你也厌倦了一成不变的IntelliJ IDEA开发环境，想换换开发风格，不妨体验一下在VSCode中开发Spring Boot程序。{message type="success" content="前置条件"/} 本文基于Mac OS进行介绍，在Windows及Linux下配置也是类似的，为了顺利完成环境搭建，你需要提前准备好以前软件及配置。JDK并完成环境变量配置。Maven并完成环境变量配置。VSCode软件{message type="warn" content="安装插件"/} 其实所谓的配置环境，不过就是安装一堆Java插件。 打开VS Code，找到【插件】页签，我们需要安装以下插件。Debugger for JavaMaven for JavaLanguage Support for Java(TM) by Red HatExtension Pack for Java{message type="error" content="使用"/} 你可以找一个现有的Spring Boot环境，或者使用脚手架大家一个简单的Spring Boot程序。{alert type="info"} 官方脚手架目前已经不支持JDK1.8，如果使用JDK1.8的话，可以使用阿里云提供的脚手架，地址为： start.aliyun.com {/alert} 使用VS Code打开代码，找到启用程序，如下图 可以点击Run运行程序或者点击Debug调试程序。 也可以打短点调试程序，这里我在启动方法中打一个短点，然后点击Debug调试程序，之后程序就会进入断点。 我们也可以安装依赖，比如下面安装lombok依赖 如果需要打包，可以在控制台输入mvn package命令通过原生Maven的方式进行打包，因为我们上面安装了Maven插件，在VS Code左下角（默认）有个Maven选项，也可以打包，与Idea基本一致。 好了，以上就是在VS Code下搭建Java（Spring Boot）开发环境的完整步骤，感兴趣的童鞋可以去尝试一下。
因为第一章都是一些概念性的东西，包括系统架构的演变、微服务架构的介绍（服务调度、服务治理、服务容错、链路追踪等等），大家感兴趣的可以阅读原文，我们这里直接从第二章微服务环境搭建开始。本次使用的电商项目中的商品、订单、用户为案例进行讲解。一、技术选型JDK ：1.8maven ：3.8.6数据库 ：MySQL 8.0.31持久层 ：SpringData Jpa其他 ：Spring Cloud Alibaba 2021.0.4.0，截止到目前最新版本开发工具 ：IntelliJ idea 2022.2## 二、模块设计springcloud-alibaba：父工程shop-common：公共模块【实体类】shop-user：用户微服务【端口：807x】shop-product：商品微服务【端口：808x】`shop-order：订单微服务【端口：809x】2.1、创建父工程打开idea，创建maven工程，选择【New Project】，输入Name、GroupId、ArtifactId，选择存储目录，JDK选择本机安装的1.8版本。点击CREATE完成项目创建。springcloud-alibaba只是作为父工程，我们不会写任何代码，所以直接把src文件夹整体删掉。然后在pom.xml中添加相关依赖<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.6.11</version> <relativePath/> </parent> <groupId>cc.lisen</groupId> <artifactId>springcloud-alibaba</artifactId> <version>1.0-SNAPSHOT</version> <packaging>pom</packaging> <properties> <java.version>1.8</java.version> <maven.compiler.source>8</maven.compiler.source> <maven.compiler.target>8</maven.compiler.target> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <spring-cloud-alibaba.version>2021.0.4.0</spring-cloud-alibaba.version> <spring-cloud.version>2021.0.4</spring-cloud.version> </properties> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>${spring-cloud.version}</version> <type>pom</type> <scope>import</scope> </dependency> <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-alibaba-dependencies</artifactId> <version>${spring-cloud.version}</version> </dependency> </dependencies> </dependencyManagement> </project>注意一下是Spring Cloud Alibaba与Spring Cloud及Spring Boot的版本对应关系，一定要选择对应的版本。Spring Cloud Alibaba VersionSpring Cloud VersionSpring Boot Version2021.0.4.0*Spring Cloud 2021.0.42.6.112021.0.1.0Spring Cloud 2021.0.12.6.32021.1Spring Cloud 2020.0.12.4.22.2、创建shop-common模块2.2.1、创建模块在工程上右键，选择NEW→Module名称输入shop-common创建模块2.2.2、添加依赖因为我们使用JPA，因此需要引入JPA的依赖，为了减少代码量，同时使用了lombok及fastjson序列化，所以shop-common添加依赖以下依赖 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>2.0.19</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.31</version> </dependency> </dependencies>2.2.3、创建包目前shop-common模块中，src文件夹还是空的，为了规范，我们把shop-common的包定义为cc.lisen.shop.common2.2.4、创建实体我们统一把实体放到entity下，创建三个实体：用户(User)、商品(Product)、订单(Order)package cc.lisen.shop.common.entity; import lombok.Data; import javax.persistence.*; /** * 用户 */ @Data @Entity @Table(name = "shop_user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer ID; /** * 用户名 */ private String name; /** * 密码 */ private String password; /** * 手机号码 */ private String telephone; } package cc.lisen.shop.common.entity; import lombok.Data; import javax.persistence.*; /** * 商品 */ @Data @Entity @Table(name = "shop_product") public class Product { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer ID; /** * 商品名 */ private String name; /** * 价格 */ private Double price; /** * 库存 */ private Integer stock; } package cc.lisen.shop.common.entity; import lombok.Data; import javax.persistence.*; /** * 订单 */ @Data @Entity @Table(name = "shop_order") public class Order { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Integer ID; /** * 用户ID */ private Integer uid; /** * 商品ID */ private Integer pid; } 2.3、创建用户微服务2.3.1、创建模块参考2.2.1创建用户模块shop-user2.3.2、添加依赖添加以下依赖即可。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>cc.lisen</groupId> <artifactId>shop-common</artifactId> <version>1.0-SNAPSHOT</version> </dependency> </dependencies>2.3.3、创建包目前shop-user模块中，src文件夹还是空的，为了规范，我们把shop-user的包定义为cc.lisen.shop.user2.3.4、编写主类shop-user作为一个微服务，必须是可独立运行的，因此必须创建一个主类UserApplication.java。package cc.lisen.shop.product; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @EntityScan({"cc.lisen.shop.common.entity"}) public class UserApplication { public static void main(String[] args) { SpringApplication.run(UserApplication.class, args); } }2.3.5、创建配置文件在resources文件夹添加application.yaml配置文件server: port: 8071 spring: application: name: service-user datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://192.168.236.2/shop?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=true username: root password: root jpa: hibernate: #指定为update，每次启动项目检测表结构有变化的时候会新增字段，表不存在时会新建，如果指定create，则每次启动项目都会清空数据并删除表，再新建 ddl-auto: update naming: #指定jpa的自动表生成策略，驼峰自动映射为下划线格式 implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl # 默认false，在日志里显示执行的sql语句 show-sql: true properties: hibernate: dialect: org.hibernate.dialect.MySQL5Dialect database: mysql database-platform: org.hibernate.dialect.MySQL5Dialect2.3.6、验证设置完成后，shop-user整个结构如下启用UserApplication，此时控制台输入一下内容，说明启动成功2.4、创建商品微服务2.4.1、创建模块参考2.2.1创建商品模块shop-product2.4.2、添加依赖添加以下依赖即可。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>cc.lisen</groupId> <artifactId>shop-common</artifactId> <version>1.0-SNAPSHOT</version> </dependency> </dependencies>2.4.3、创建包目前shop-product模块中，src文件夹还是空的，为了规范，我们把shop-product的包定义为cc.lisen.shop.product2.4.4、编写主类shop-product作为一个微服务，必须是可独立运行的，因此必须创建一个主类ProductApplication.java。package cc.lisen.shop.user; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @EntityScan({"cc.lisen.shop.common.entity"}) public class ProductApplication { public static void main(String[] args) { SpringApplication.run(ProductApplication.class, args); } }2.4.5、创建配置文件在resources文件夹添加application.yaml配置文件server: port: 8081 spring: application: name: service-product datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://192.168.236.2/shop?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=true username: root password: root jpa: hibernate: #指定为update，每次启动项目检测表结构有变化的时候会新增字段，表不存在时会新建，如果指定create，则每次启动项目都会清空数据并删除表，再新建 ddl-auto: update naming: #指定jpa的自动表生成策略，驼峰自动映射为下划线格式 implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl # 默认false，在日志里显示执行的sql语句 show-sql: true properties: hibernate: dialect: org.hibernate.dialect.MySQL5Dialect database: mysql database-platform: org.hibernate.dialect.MySQL5Dialect2.4.6、验证设置完成后，shop-product整个结构如下启用ProductApplication，此时控制台输入一下内容，说明启动成功2.5、创建订单微服务2.5.1、创建模块参考2.2.1创建商品模块shop-order2.5.2、添加依赖添加以下依赖即可。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>cc.lisen</groupId> <artifactId>shop-common</artifactId> <version>1.0-SNAPSHOT</version> </dependency> </dependencies>2.5.3、创建包目前shop-order模块中，src文件夹还是空的，为了规范，我们把shop-product的包定义为cc.lisen.shop.order2.5.4、编写主类shop-order作为一个微服务，必须是可独立运行的，因此必须创建一个主类OrderApplication.java。package cc.lisen.shop.order; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @EntityScan({"cc.lisen.shop.common.entity"}) public class OrderApplication { public static void main(String[] args) { SpringApplication.run(OrderApplication.class, args); } }2.5.5、创建配置文件在resources文件夹添加application.yaml配置文件server: port: 8091 spring: application: name: service-order datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://192.168.236.2/shop?serverTimezone=UTC&characterEncoding=utf8&useUnicode=true&useSSL=true username: root password: root jpa: hibernate: #指定为update，每次启动项目检测表结构有变化的时候会新增字段，表不存在时会新建，如果指定create，则每次启动项目都会清空数据并删除表，再新建 ddl-auto: update naming: #指定jpa的自动表生成策略，驼峰自动映射为下划线格式 implicit-strategy: org.hibernate.boot.model.naming.ImplicitNamingStrategyLegacyJpaImpl # 默认false，在日志里显示执行的sql语句 show-sql: true properties: hibernate: dialect: org.hibernate.dialect.MySQL5Dialect database: mysql database-platform: org.hibernate.dialect.MySQL5Dialect2.5.6、验证设置完成后，shop-order整个结构如下启用OrderApplication，此时控制台输入一下内容，说明启动成功三、原始服务调用3.1、创建测试数据为了方便后续演示，我们现在用户及商品表中创建几条测试数据。INSERT INTO shop_user (id, name, password, telephone) VALUES (1, '张三', '123456', '13333333333'); INSERT INTO shop_user (id, name, password, telephone) VALUES (2, '李四', '123456', '14444444444'); INSERT INTO shop_product (id, name, price, stock) VALUES (1, '小米', 1000, 5000); INSERT INTO shop_product (id, name, price, stock) VALUES (2, '华为', 2000, 5000); INSERT INTO shop_product (id, name, price, stock) VALUES (3, '苹果', 3000, 5000); INSERT INTO shop_product (id, name, price, stock) VALUES (4, '一加', 4000, 5000); 3.2、商品提供查询服务3.2.1、数据访问层创建商品数据访问层一个空的接口，JPA默认会提供查询方法package cc.lisen.shop.product.dao; import cc.lisen.shop.common.entity.Product; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Repository; /** * 商品数据访问层 */ @Repository public interface ProductDao extends JpaRepository<Product, Integer> { } 3.2.2、服务层创建ProductService及接口实现类package cc.lisen.shop.product.service; import cc.lisen.shop.common.entity.Product; public interface ProductService { /** * 根据ID查询商品 * * @param ID 商品ID * @return 商品 */ Product findByID(Integer ID); } package cc.lisen.shop.product.service.impl; import cc.lisen.shop.common.entity.Product; import cc.lisen.shop.product.dao.ProductDao; import cc.lisen.shop.product.service.ProductService; import org.springframework.stereotype.Service; import javax.annotation.Resource; @Service public class ProductServiceImpl implements ProductService { @Resource private ProductDao productDao; /** * 根据ID查询商品 * * @param ID 商品ID * @return 商品 */ @Override public Product findByID(Integer ID) { return productDao.findById(ID).get(); } } 3.2.3、创建Rest接口package cc.lisen.shop.product.controller; import lombok.extern.slf4j.Slf4j; import cc.lisen.shop.common.entity.Product; import cc.lisen.shop.product.service.ProductService; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; @RestController @Slf4j public class ProductController { @Resource private ProductService productService; @GetMapping("/product/{id}") public Product product(@PathVariable("id") Integer ID) { return productService.findByID(ID); } } 运行程序，现在浏览器测试一下3.3、订单查询商品3.3.1、创建配置文件我们这里通过RestTemplate访问商品，因此增加一个配置文件。package cc.lisen.shop.order.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.client.RestTemplate; @Configuration public class OrderConfiguration { @Bean public RestTemplate getRestTemplate(){ return new RestTemplate(); } } 3.3.1、创建Rest接口这里简单模拟一下订单查询商品信息，只简单创建一个订单的controllerpackage cc.lisen.shop.order.controller; import lombok.extern.slf4j.Slf4j; import cc.lisen.shop.common.entity.Product; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.PathVariable; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import org.springframework.web.client.RestTemplate; import javax.annotation.Resource; @RestController @RequestMapping("order") @Slf4j public class OrderController { @Resource private RestTemplate restTemplate; @GetMapping("product/{id}") public Product order(@PathVariable("id") Integer productID){ return restTemplate.getForObject("http://localhost:8081/product/1", Product.class); } } 简单测试一下订单接口接口也是能够正常访问的。四、传统服务调用的一些弊端通过上面的代码，我们虽然实现了接口的调用，但是我们把服务提供者的网络地址（ip、端口）等硬编码到了代码中，这种做法存在很多问题：一旦服务提供者地址发生变化，就需要手工修改代码（当然可以做成配置或者放到配置文件中）一旦是多个服务提供者，无法实现负载均衡功能一旦服务变得越来越多，人工维护调用关系变得非常困难为了解决上述问题，我们就引出了微服务架构中的服务治理，也就是通过注册中心等方式，实现服务的自动注册与发现。