GreenTea Java用户组meetup圆桌主持稿

需要各位老师做的事情：

1. 提前审阅问题，对不合适的问题提出修改建议；

2. 如果认可问题的价值，在会前准备好回答的思路；如有可能，提前整理成文字版，保证现场高质量高密度输出；

3. 知悉：我会基于现场的圆桌整理《Java x AI年终技术盘点》投稿至主流技术媒体发布，录制后的视频会定向推送给研发同学。

主持稿和问题：

“各位开发者朋友，大家好！欢迎来到本次《从微服务到“智服务”：Java开发者在AI时代下的创新与破局》圆桌讨论。我是主持人王蓉。

今天我们很荣幸邀请到五位深耕Java生态多年的资深专家——他们中有主导过亿级用户系统架构的架构师、有xxx、有xxx。

为什么今天要聊这个话题？ 因为我们看到：一边是以Python为核心语言的LLM和Agentic架构的势不可挡；一边是全球超900万Java开发者仍在维护着金融、电商、物流等核心系统。Java真的‘老’了吗？还是正迎来新一轮爆发？

接下来一个多小时，我们将围绕四个关键问题展开：挑战、现状、优势短板、Agentic架构升级路径、个人成长。每位嘉宾将分享自己的观察和洞见，最后留一些时间给大家提问。

首先，我们请各位嘉宾简单自我介绍一下

沈询：简短介绍，突出与议题相关性

温绍锦：简短介绍，突出与议题相关性

李三红：简短介绍，突出与议题相关性

莫简豪：简短介绍，突出与议题相关性

**【问题1：一线开发者的现实挑战】（15分钟） **感谢各位！我们直接进入第一个痛点：业务要求越来越‘智能’，但Java系统往往背负着沉重的历史包袱：
在推动业务创新（比如接入AI能力）时，您遇到或者看到的最大技术阻力是什么？是团队技能断层、架构僵化，还是工具链缺失？能否分享一个具体案例？

（聚焦可复现的场景，如果有可能，讲具体“故事”而非罗列问题）

【问题2：2025年值得关注的Java x AI技术热点】**（15分钟） **请各位嘉宾回顾一下2025年值得我们关注的Java x AI生态的基础设施层的关键技术演进和应用开发层的优秀开源项目/框架，帮助我们快速catch up一下。

**【问题3：Java在AI时代的不可替代性 vs 短板】（15分钟） **接下来想和各位探讨一下Java在AI时代的优势和短板。Python因AI爆火，Go因云原生崛起，Java是否还有不可替代的优势？再请分享一下您认为Java在AI时代的核心优势，以及最需补强的短板，未来哪些关键技术演进值得我们关注的？

【问题3：平滑升级至Agentic架构的实践路径】（15分钟）
很多团队想拥抱Agentic架构，如何让现有Java系统平滑地进化？请分享您的架构选型思路。

【问题4：Java开发者的个人成长建议】（15分钟）
最后，回归到我们开发者本身。在AI重构技术栈的浪潮中，Java开发者该如何与时代共振，甚至成为引领者？如果给一位5年经验的Java工程师一个非常具体的建议，您会建议他/她要掌握哪些核心的AI相关的技能？

【结束语】（1分钟）
“感谢五位嘉宾毫无保留的分享和洞察！也感谢大家的深度参与。

最后送大家一句话：技术没有银弹，Java的工程化基因和生态韧性，恰恰是AI落地最需要的‘压舱石’。

AI需要Java这样的可靠底座。

圆桌资料我们会整理成文稿发布，关注[公众号]获取。下次见！

GreenTea Java User Group Meetup Roundtable Moderator's Script

What you teachers need to do:

1. Review the questions in advance and suggest modifications for any inappropriate ones;

2. If you recognize the value of the question, prepare your answer ideas before the meeting; if possible, transcribe it into a written version in advance to ensure high-quality, high-density output on the spot.

3. Please note: I will compile the "Java x AI Year-End Technical Review" based on the roundtable discussion and submit it to mainstream technical media for publication. The recorded video will be pushed to R&D colleagues.

Script and questions:

"Hello everyone, fellow developers! Welcome to the roundtable discussion, 'From Microservices to 'Intelligent Services': Innovation and Breakthroughs for Java Developers in the AI ​​Era.' I'm your moderator, Wang Rong."

Today we are honored to have invited five senior experts who have been deeply involved in the Java ecosystem for many years—among them are architects who have led the architecture of systems with hundreds of millions of users, xxx, and xxx.

Why discuss this topic today? Because we see the unstoppable rise of LLM and Agentic architectures, with Python as their core language; and the continued presence of over 9 million Java developers worldwide maintaining core systems in finance, e-commerce, and logistics. Is Java truly 'old'? Or is it poised for a new surge in popularity?

Over the next hour, we will focus on four key questions: challenges, current situation, strengths and weaknesses, Agentic architecture upgrade path, and personal growth. Each speaker will share their observations and insights, and a Q&A session will be held at the end.

First, let's ask each of our guests to briefly introduce themselves.

Inquiry: A brief introduction highlighting its relevance to the topic.

Wen Shaojin: Brief introduction, highlighting relevance to the topic.

Li Sanhong: Brief introduction, highlighting relevance to the topic.

Mo Jianhao: Brief introduction, highlighting relevance to the topic.

[Question 1: The Real-World Challenges Faced by Frontline Developers] (15 minutes)

Thank you all! Let's get straight to the first pain point: business requirements are becoming increasingly 'intelligent,' but Java systems often carry a heavy historical burden:

When driving business innovation (such as integrating AI capabilities), what is the biggest technical obstacle you have encountered or seen?

As you stated right at the outset, “Java systems often carry a heavy historical burden.” As someone who has personally created some of the technology included in that burden, first I want to reframe the word more accurately. Java systems continue to exist for decades because they have long-ago earned out their initial investment and continue to provide return. This was the key value prop for Java from the beginning. The legacy continued into J2EE, then Spring, Java EE and Jakarta EE. Now, let’s take your question for applications that haven’t been substantially modified in years, to make any changes, AI or otherwise, it is prudent to bring the application up to date first. This is where our team’s new GitHub Copilot App Modernization family of products comes into play. But once the app is ready for modification, I have seen the biggest challenge to be finding the right fit for Gen AI in the app.

One common pattern seen in demos, and sometimes in actual products, is the “just add a chatbot” thing. Sure, that works fine, but deeper integration is more challenging.

Is it a gap in team skills, rigid architecture, or a lack of toolchain?

these are all very likely contributors. To skills gap, I will also add awareness gaps. The state of the art for Java in AI has absolutely improved over the last few years, to the point where it is no longer safe to assume one has to write in Python to access the features of AI.

Could you share a specific example?

(Focus on reproducible scenarios, and if possible, tell specific "stories" rather than listing problems.)

I can cite the example of how we added AI driven shortest path detection to the Jakarta EE Cargo Tracker app.

[Question 2: Key Java x AI technologies to watch in 2025](15 minutes)

Please have our guests review the key technological evolutions in the infrastructure layer of the Java x AI ecosystem and the outstanding open-source projects/frameworks in the application development layer that are worth paying attention to in 2025, so that we can quickly catch up.

well, the topic of my talk is Langchain4j-cdi, and this is simply a CDI ease-of-use layer on top of LangChain4j. But in addition to that, the buzzword of the year is agentic.

"Let’s talk about Agent-to-Agent, or A2A, in the Java ecosystem. Multi-agent collaboration is becoming critical for complex AI workflows, and two frameworks stand out: LangChain4j and Spring AI.

First, LangChain4j. It’s designed for orchestrating LLM workflows in vanilla Java and therefore usable with most frameworks and specifications such as Spring Boot, Quarkus, Micronaut, etc .The emerging pattern here is a coordinator-specialist model. You define specialist agents—each with its own tools and prompts—and a coordinator agent that decomposes tasks, routes them, and merges results. This pattern scales well for enterprise use cases. LangChain4j also supports CDI integration, making it easier to wire agents into Java EE or Jakarta environments.

Next, Spring AI. It brings AI into the Spring Boot ecosystem. You can compose agents as Spring beans, use ChatClient for LLM calls, and integrate vector stores for RAG. For multi-agent orchestration, Spring AI leverages familiar Spring patterns—dependency injection, messaging, and reactive flows—so developers can build agent topologies without leaving the Spring world.

Finally, interoperability. A2A and MCP protocols are emerging as standards for cross-runtime collaboration. This means your Java agents can talk to Python or JavaScript agents seamlessly, using HTTP or gRPC bridges.

Bottom line: LangChain4j and Spring AI give Java developers a clear path to build agentic architectures without abandoning the JVM. Start small—define a coordinator and two specialists—and scale up as your workflows grow."

Finally, speaking of Spring, I believe we need to keep our eyes on Rod Johnson’s Embabel (pronounced Em BAY bell). This is another implementation of the coordinator-specialist model but with Rod Johnson’s signature aesthetic of cohesion and simplicity.

Looking ahead to 2025, the Java × AI ecosystem is evolving across two layers: infrastructure and application.

Infrastructure Layer

Three technologies stand out:

• Project Loom – Virtual threads for massive concurrency
• Project Panama – High-performance native ML interop
• GraalVM – Ultra-fast startup and optimized AI microservices

Application Layer

Key frameworks and libraries:

• LangChain4j – Vanilla Java library for LLM workflows; framework-agnostic, works with Spring Boot, Quarkus, Micronaut
• Spring AI – Brings AI into the Spring ecosystem with ChatClient, RAG, and vector store integrations
• Semantic Kernel for Java – Agentic orchestration
• DJL (Deep Java Library) – Run ML models natively in Java

Emerging Patterns

• Retrieval-Augmented Generation (RAG)
• Model Context Protocol (MCP)
  These patterns will drive multi-agent and agent-to-agent collaboration.

Bottom line:
Java developers can adopt AI without leaving the JVM, leveraging these tools for performance, scalability, and compliance.

[Question 3: Java's irreplaceable role vs. its shortcomings in the AI ​​era] (15 minutes)

Next, I'd like to discuss Java's strengths and weaknesses in the AI ​​era. Python has become incredibly popular due to AI, and Go has risen to prominence because of cloud-native technologies. Does Java still possess irreplaceable advantages? Please also share what you believe to be Java's core strengths in the AI ​​era, and its most pressing weaknesses that need improvement.

What key technological evolutions should we pay attention to in the future?

The core strengths are the same as ever, and I must say they flow very clearly from the excellent stewardship of the Java Platform Group at Oracle and Jakarta EE for the JDK and enterprise stacks respectively. These old strengths are a

• culture of backward compatibility

• continued support

• performance optimizing innovation

• avoidance of chasing the latest hot trend at the expense of platform integrity

• Project Valhalla: value types: better for vectorization and compute heavy work

• Project Leyden: the fast start and container/serverless friendliness of native Java with the benefits of JVM bytecode (Dynatrace, etc)

• Rock solid and mature build-time tooling: maven, gradle, CI/CD awareness of both.

Incidentally, many of these strengths enable LLM based modernization solutions such as GHCP-appmod because there is so much Java in LLM training sets.

[Question 3: Practical Path to a Smooth Upgrade to Agentic Architecture] (15 minutes)

Many teams want to embrace Agentic architecture. How can existing Java systems evolve smoothly? Please share your architecture selection process.

First, I would remind us that we’ve been here before: remember when “decomposing your monolith to microservices” was the big thing? And after we did that, we realized that some of those microservices might be better implemented as serverless functions? I suspect the architecture selection will involve similar decomposition, with the added journey of being aware of how to effectively prompt.

As far as selection goes, it’s best to leave the frontier innovation to the experts. Here’s why. Let’s take a look at when Microservices entered the scene. Eventually we all settled on Sam Newman’s “Building Microservices” book. I believe it is too early to ask for the same level of architectural clarity about agents. Maybe Lillian Weng’s blog https://lilianweng.github.io/ or Ethan Mollick’s substack https://substack.com/@oneusefulthing

[Question 4: Advice on Personal Growth for Java Developers] (15 minutes)

Finally, let's return to the developers themselves. In the wave of AI reshaping the technology stack, how can Java developers resonate with the times, or even become leaders? If you were to give a Java engineer with 5 years of experience very specific advice, what core AI-related skills would you recommend they master?

Ahh, I have a lot to say here. I wrote an old book on this topic in 2008, and some dear friends of mine updated the idea in 2024 in the book “Developer Career Masterplan”. I gave a keynote on it at https://aka.ms/DeveloperCareerMasterPlan/video and the slides are at https://aka.ms/DeveloperCareerMasterplan/slides . The good part is that all of this still applies in the age of AI, but of course everything is faster.

[Closing Remarks] (1 minute)

"Thank you to the five guests for their candid sharing and insights! And thank you to everyone for your deep participation."

Finally, I'd like to leave you with this thought: There is no silver bullet in technology. Java's engineering DNA and ecosystem resilience are precisely the 'ballast' most needed for the implementation of AI.

AI needs a reliable foundation like Java.

We will compile the roundtable discussion into a written document and publish it; follow our [WeChat Official Account] to access it. See you next time!