精华内容
下载资源
问答
  • jakarta ee_Jakarta EE 8状态
    2020-07-06 20:25:52

    jakarta ee

    遵循Jakarta EE的人们可能知道即将发布的Jakarta EE 8在功能上将与Java EE 8等效。其原因是我们想证明从Oracle的传输已经完成,并且我们能够产生这些流程,规范,测试套件以及通过Eclipse Foundation的兼容实现。

    到目前为止, Eclipse GlassFish 5.1已发布并通过了Java EE 8兼容认证。 下一步是为Jakarta EE 8进行所有设置,并发布与Jakarta EE 8兼容的Eclipse GlassFish 5.2。

    要发布Jakarta EE 8,需要完成的任务之一就是将现有的Java EE规范文档转换为Jakarta EE。 这将涉及根据Oracle与Eclipse Foundation *之间的商标协议重命名规范。

    除此之外,将需要更新包含适用于各个规范的API的现有EE4J项目的范围,并将这些项目本身转换为Eclipse Foundation Specification Process (EFSP)中定义的Ja karta EE规范项目 。 Jakarta EE规范流程将是EFSP的专业化。

    为了跟踪所有这些,我们在Jakarta EE Platform GitHub项目中创建了一个计划委员会。

    雅加达EE 8

    为了使Jakarta EE 8脱颖而出,我在本文中描述的只是规范方面的几件事。 还有很多其他涉及TCK的活动,至少也需要完成Eclipse GlassFish 5.2。 但是目前,最关键的项目是克服商标协议的法律障碍以及将规范文档转移到Eclipse Foundation。

    *)在发布此博客文章时,尚未定义此协议的详细信息。

    翻译自: https://www.javacodegeeks.com/2019/03/jakarta-ee-8-status.html

    jakarta ee

    更多相关内容
  • Jakarta EE 9入门样板(WIP) 这是什么? 的目标是提供一个简单的模板,以帮助开发人员在几秒钟内启动Jakarta EE 9项目。 当迁移到Jakarta EE 9平台时,它还包括我的个人开发说明。 文件 部署到WildFly 部署到...
  • jakartaee9-servlet-启动器样板(WIP) 是的,这是Jakarta EE开发人员的另一个入门入门样板项目。 该存储库是原始的轻量级变体,可让您在与Servlet 5.0兼容的容器上运行应用程序,例如Apache Tomcat,Eclipse ...
  • 此存储库显示了将Java / Jakarta EE应用程序部署到Azure的关键方法。 存储库托管演讲或实验的演示(是实验的说明)。 是演讲的视频。 整个过程中使用的基本Jakarta EE应用程序位于文件夹中。 您应该首先浏览该...
  • Jakarta EE 8(Java EE)和MicroProfile 3.2应用程序生成器和建模器 主要特点 1) 2)Java EE 8 / MicroProfile全栈应用程序生成器 3)可视化架构 4)Java源代码的逆向工程 5)可视化创建数据库结构 6)JSONB建模器 ...
  • JakartaEE Spring MVC

    2018-04-16 17:32:05
    压缩包中为JakartaEE的项目,为SpringMVC测试项目,简单的使用了SpringMVC
  • 探索Jakarta EE MVC功能。 是基于JAX-RS的Jakarta Enterprise Edition的参考实现。 安装指南在 通过扩展ee.jakarta.mvc.MvcConfiguration javax.ws.rs.ApplicationPath来配置根路径 默认视图位置WEB-INF / views ...
  • 从Java EEJakarta EE,企业版Java的发展历程

    千次阅读 多人点赞 2021-07-02 05:03:05
    <groupId>javaxgroupId> <artifactId>javaee-apiartifactId> <version>6.0.0version> <scope>providedscope> dependency> <dependency> <groupId>jakarta.platformgroupId> <artifactId>jakarta.jakartaee-...

    眼看他起高楼,眼看他宴宾客,眼看他楼塌了
    本文已被https://yourbatman.cn收录;程序员专用网盘https://wangpan.yourbatman.cn;公号后台回复“专栏列表”获取全部小而美的原创技术专栏

    ✍前言

    你好,我是方同学(YourBatman)

    A哥 -> 方同学。是的,中文昵称改了。自知道行不深无以用“哥”字称呼,虽已毕业多年,同学二字寄寓心态一直积极、热情、年轻

    诞生于1995年的Java语言,年近三旬,甚至比很多同学的年龄还大得多。正所谓三十年河东,三十年河西,有人说Java已廉颇老矣,基本结构过于老套不灵活,但显示情况是它“老而不死”依旧常年霸榜,是棵常青树。

    深爱Java的同学知道,Java并不老(Python年纪更大)、开发效率并不低(马拉松型选手看中长远效率)、语法并不是啰嗦(这是严谨的表现,同时也拥抱了Stream流式、Function函数式编程来简化开发)。Java鼓励用严谨的方法、正确的方式来设置内容,这让Java程序员们对待代码更有全局性,更适合构建规模性的企业级项目。

    另外,Java做到了哪怕最新版JDK能(几乎)100%兼容首个版本,这无不依靠于优秀的设计和规范的制定。2000年左右随着Java的高速发展,被大量用于企业应用的开发,所以迫切需要规范的解决方案。

    正所谓一流企业定标准、二流企业做品牌、三流企业做产品 ,这个活Sun公司自然不会放过,它就是企业版Java,也叫Java EE(后改名为Jakarta EE)。Java EE是一些列技术标准的集合(只定标准,不提供实现),其中很多技术经历这么多年的发展已经很成熟、应用得很广泛了。但深入了解后会发现,Java EE很多技术都是起个大早,赶个晚集,否则也不会有Spring现在的绝对霸主地位。
    在这里插入图片描述

    所属专栏

    相关下载

    本文提纲

    在这里插入图片描述

    版本约定

    • Java EE:6、7、8
    • Jakarta EE:8、9、9.1

    ✍正文

    上面说到,Java能够历久弥新得益于它是非常严谨的、注重编码规范、注重设计规范的编程语言。按照规范实施做到有据可循,实施过程又可反馈给规范,形成正反馈的周而复始,越来越完善。
    在这里插入图片描述
    本专栏将介绍Java EE/Jakarta EE相关的几十种技术,作为Java企业级开发的标准技术,很多技术应用非常广泛。本文作为第一篇,将从发展历程出发,先一起全方位的了解到它。

    JDK发展简史

    在讲述Java EE的发展历程之前,先简要回顾(普及)一下JDK的发展史,方便在时间上对应参照,毕竟开发者一般对JDK的版本会更熟、更敏感些。

    诞生:1995年5月,Oak语言改名为Java,标志着Java的诞生,并且提出了著名的Write Once,Run Anywhere口号。下面用表格形式记录其发版时间轴

    版本发布日期焦点说明
    JDK 1.01996.01Java虚拟机、基础类库
    JDK 1.11997.02规定了Jar文件格式,JDBC、JavaBeans、RMI等。开始支持内部类和反射
    JDK 1.21998.12引入集合框架Collections、Map等。从此版本开始,分为3个版本:J2SE/J2EE/J2ME(注:1999.04著名的HotSpot虚拟机诞生,顺势推出了Java EE首个版本)
    JDK 1.32000.05千禧年的第一个版本,对类库进行了优化
    JDK 1.42002.02支持正则Pattern、NIO、JDBC 3.0、assert断言
    JDK 52004.09JDK命名方式变化、自动拆装箱、泛型、枚举、可变参数、增强for循环、JUC并发包等等非常多新特性
    JDK 62006.12编译器注解处理器(lombok的原理)、J2xx改为Java XX
    JDK 72009.02try-with-resources、NIO2(也叫AIO)、泛型推断
    JDK 82014.03憋了5年的大招,果然经典。Lambda表达式、函数式编程、Stream流式编程、方法引用、接口默认方法、彻底移除HotSpot的永久代
    JDK 112018.09Jigsaw模块化、增强类型推断、革命性的垃圾收集器ZGC
    JDK 172021.09…敬请期待

    期间,关于Java/Sun公司有些大事记,记录一下

    日期事件
    1995.05Java语言诞生
    1996.01JDK 1.0版本发布
    1998.12JAVA2企业平台J2EE发布(和JDK 1.2一起)
    2005.06JavaOne大会召开(Java诞生10周年),J2EE更名为Java EE, J2SE更名为Java SE,J2ME更名为Java ME
    2009.04甲骨文Oracle以现金收购Sun微系统公司,交易价格74亿美元(Sun公司市值顶峰时超2000亿美金。眼看他起高楼,眼看他宴宾客,眼看他楼塌了)。Sun公司最大的资产,便是Java。从此Java商标被Oracle收入囊中,才有了后来的Oracle PK Google大战
    2017.08Oracle将Java EE(Java SE还自己保留)交给开源组织,Eclipse基金会接手。但Oracle不允许开源组织使用Java名号,所以Jakarta EE名称于2018.02.26应运而生

    什么是Java EE?

    作为一个(资深)的Java开发者,这似乎是一个很简单的问题。

    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。它分为三个版本:

    • Java SE(J2SE):标准版。基础中的基础,后面2个版本都依赖于它。当前最新版本是Java 17(LTS版本,将于2021年9月发布)
    • Java EE(J2EE):企业版。用于企业级大型应用开发,包含了Web、Security、Management等几十种标准技术
    • Java ME(J2ME):移动版。随着Android/iOS的流行,它已几乎销声匿迹

    由于Java EE能够直接应用于企业级应用开发,解决实际问题,直接产生价值,因此也常说它价值更高。所以用谷歌百度一下“Java培训”关键字,基本都是培训Java EE的。

    作为common sense,特别是Java程序员除了需对JDK的历史有所了解外,Java EE的发展历程也是有必要知道的,毕竟这是基础知识点,是聊天的谈资,是你的内功

    Java EE发展史

    J2EE(JavaEE)自1999年首次发布以来,已成为实现和部署可移植、多层企业应用程序的集成标准(它是标准,它是规范),现在了解下它的发展史,记录到如下表格(从成体系的Java EE 1.4版本开始)。

    说明:该表格是YourBatman翻阅多处资料搜集整合,全网最全的一份,请收藏使用。转载请注明出处

    版本发布日期焦点说明
    J2EE 1.42003.12对Web服务更好支持。启用javax命名空间。Servlet 2.4、JSP 2.0、EJB 2.1等
    Java EE 52006.05以Web为着力点继续优化。Servlet 2.5、JSP 2.1、EJB 3.0、注解支持等
    Java EE 62009.12添加了大量新技术来简化开发,如:Servlet 3.0(异步处理)、Bean Validation、EJB 3.1、JSF 2.0、JPA 2.0、上下文和依赖注入(CDI)
    Java EE 72013.06提高生产力满足企业需求和HTML5。Servlet 3.1、WebSocket 1.0、JSON 1.0、JMX 2.0、Batch 1.0
    Java EE 82017.08增加了JSON绑定和安全相关。Servlet 4.0、Bean Validation 2.0、CDI 2.0、JPA 2.2
    Jakarta EE入局2017.08Oracle将Java EE交给开源组织,Eclipse基金会接手(Apache基金会爆冷出局还是不想要?)。但Oracle不允许开源组织使用Java名号,所以Jakarta EE名称于2018.02.26应运而生
    Jakarta EE 82019.09规范与Java EE 8完全相同。Maven的GAV变了:javax.servlet:javax.servlet-api:4.0.1 -> jakarta.servlet:jakarta.servlet-api:4.0.2,但命名空间没变依旧还是javax.*,算是个小过度吧
    Jakarta EE 92020.11没有加入新功能,Eclipse基金会的首个正式版本。命名空间从javax.*迁移到jakarta.*,前者从此成为历史。所有模块大版本号+1,如Servlet 4.0.2 -> Servlet 5以表示其断层式升级
    Jakarta EE 9.12021.06相较于9 没有 加入新API。主要提供对Java SE 11的运行支持

    2017年随着Oracle把Java EE交给开源基金会,Java EE从此成为历史,接下来将由社区驱动的Jakarta EE取而代之。
    在这里插入图片描述

    虽然Java EE已成过去式,但它似乎代表着我们的程序青春,依然是沟通的主力。因此,在很长很长很长一段时间内,Java EE知名度依旧盖过Jakarta EE,沟通交流中使用它居多。

    Tips:Java EE版本号和Java SE没有绝对联系。如即使到最新的Jakarta EE 9、9.1版本对JDK的最低要求是8,而非9

    咱们程序员可能会吐槽Oracle为毛不让使用Java EE商标,这么搞太费劲了。但在Oracle眼中,可能,一切都是利益(Oracle号称是一个律师比工程师数量还多的高科技企业)

    补充:什么是Eclipse基金会

    2004年2月该非盈利组织的正式成立,由包括开发者、消费者和插件提供商在内的各独立团体组成的董事会,为Eclipse的长期发展负责,它就是Eclipse基金会。

    该基金会最初只有19个开源项目,现在有300+个之多,我们比较熟悉的就有:

    • Java开发工具:功能强大的Java开发IDE Eclipse
    • 众多Jakarta项目:Jakarta Annotations、Jakarta Bean Validation、Jakarta JSON Processing等等
    • Vert.X:一个面向现代web和企业的异步应用框架,一个可能会撼动Spring地位的全家桶框架

    另外,可把Eclipse基金会和Apache基金会对照着看,程序员对后者理应更熟悉些。

    什么是Jakarta EE

    在这里插入图片描述
    该名称的由来和两个大事记有关:

    1. 为了让Java EE更开放,Oracle决定为它寻找一个新东家(呵呵,我笑而不语)。2017年8月,Oracle将Java EE交给开源组织,Eclipse基金会接手(Apache爆冷出局还是不想要?)
    2. Oracle拒绝让基金会继续使用Java名字,因此Eclipse做了一项名义调查,从Jakarta EE和Enterprise Profile两个名称中二选一,前者大比例胜出。所以在2018年3月份,Eclipse宣布正式将Java EE更名为Jakarta EE,并且确定了logo(如上图)。另外,跟着更名的还有一些和Java EE紧密相关的名词,如Glassfish -> Eclipse Glassfish;JCP -> EE.next;ODM(Oracle Development Management) -> PMC

    总而言之:Jakarta EE你可认为它(的内容)就是Java EE,只是名字换了,老东家换了。之前由JCP来推动它的发展,以后将有开源社区推动。至于前景如何,咱们拭目以待

    Jakarta EE发展史

    Jakarta EE还很年轻,2017年8月从Oracle手中接棒过来算起,也不过4岁,谈不上什么发展史,是好是坏周期太短也不能早下定论。截止到目前,共发布了三个版本,内容几乎没有变化,只在命名空间、版本号方面稍有改变,记录如下:

    版本发布日期焦点说明
    Jakarta EE 82019.09规范与Java EE 8完全相同。Maven的GAV变了:javax.servlet:javax.servlet-api:4.0.1 -> jakarta.servlet:jakarta.servlet-api:4.0.2,但命名空间没变依旧还是javax.*,算是个小过度吧
    Jakarta EE 92020.11没有加入新功能,Eclipse基金会的首个正式版本。命名空间从javax.*迁移到jakarta.*,前者从此成为历史。所有模块大版本号+1,如Servlet 4.0.2 -> Servlet 5以表示其断层式升级
    Jakarta EE 9.12021.06相较于9 没有 加入新API。主要提供对Java SE 11的运行支持

    一站式聚合API

    如你所知,Java EE/Jakarta EE是几十种技术(规范)的几何,几乎每种技术都有其API(对应一个Jar),为了方便总揽全局,Java EE自6版起提供了一站式聚合API,导入一个就够了:

    <dependency>
       <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>6.0.0</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- Jakarta命名空间版本 -->
    <dependency>
        <groupId>jakarta.platform</groupId>
        <artifactId>jakarta.jakartaee-api</artifactId>
        <version>9.1.0</version>
        <scope>provided</scope>
    </dependency>
    

    效果如下:
    在这里插入图片描述
    特别注意:实际工作中不建议使用这种粗暴的、大而全的导入方案,而是应该按需导入精确把握,还classpath一片“干净”,并且也能做到心中有数,方可运筹帷幄。

    有Java EE SDK吗?

    既然Java SE有JDK,那么Java EE是否也有SDK呢?答案:有的。Oracle官网/Jakarta EE官网均提供了SDK供以下载:https://www.oracle.com/java/technologies/javaee-8-sdk-downloads.html

    只不过此SDK可能让你失望了,它不是传统的软件开发工具包,而更像是一个技术合集,并且和自家的Glassfish强绑定,包含有以下内容:

    • doc官方文档
    • 几十种技术的使用samples(基于Maven管理、构建)
    • glassfish容器,强耦合

    总的来讲,如若是抱着学一学的目的那么可以down下来玩玩,毕竟里面的samples示例、文档比较全。如若你是抱着使用的目的,那就不建议了,毕竟glassfish我们(国内)很少使用。

    ✍总结

    30年弹指一挥间,Java EE在逐渐淡出Java开发者的视野,但中短期来看它依旧是我们绕不过的内容,经常能听到、看到、聊到。当在研究Spring等开源框架的时候,也经常会看到Java EE的影子。

    本文介绍了Java EE的发展史,目的是对它有个笼统的认识。从Java EE到Jakarta EE,它能否重新焕发生命力我不知道,但留下来的不少东西依旧是目前的主流(如Servlet规范、JPA等等),具有非常高的学习价值,切莫轻视。

    下篇文章将介绍Java EE/Jakarta EE的30余种技术(可能你只听过Java EE的13种核心技术),敬请关注本专栏。

    相关下载

    在这里插入图片描述

    本网盘现已开放注册,注册地址:https://wangpan.yourbatman.cn/signup

    推荐阅读

    System.out.println("写得可还行?收藏再看吧,点个赞吧,分享下吧");
    echo("关注【BAT的乌托邦】 https://yourbatman.cn");
    console.log("私聊YourBatman:fsx1056342982");
    

    我是YourBatman:一个早在2013年就已毕业的大龄程序员。网瘾失足、清考、延期毕业、房产中介、送外卖、销售…是我不可抹灭的标签。现在是一个纯粹技术工。

    • 2013.08-2014.07宁夏银川中介公司卖二手房1年,毕业后第1份工作
    • 2014.07-2015.05荆州/武汉/北京,从事炸鸡排、卖保险、直销、送外卖工作,这是第2,3,4,5份工作
    • 2015.08开始从事Java开发,做过兼职,闯过外包,呆过大厂!现为我司基础架构团队负责人
    • Java架构师、Spring开源贡献者,CSDN 2019博客之星Top 10,博客专家,领域建模专家。热衷写代码,有代码洁癖;重视基础和基建,相信效率为王
    • 现在写纯粹技术专栏(公号后台回复专栏列表获取全部),不哗众取宠。如果你也有共鸣,可加我好友(fsx1056342982)一起进步哈(备注:java)
    展开全文
  • This book covers the very essentials of the CDI API and aims at explaining the various constructs in a way that is easy to understand and relate to. The ultimate goal is to help you, the everyday ...
  • jakarta ee 城镇中有一个名为Micronaut的新微服务框架。 在本文中,我将从Java EE / Jakarta EE的角度讨论如何冒险使用Micronaut框架。 我是Java EE开发人员,因此使用诸如Eclipse MicroProfile之类的解决方案开发...

    jakarta ee

    城镇中有一个名为Micronaut的新微服务框架。 在本文中,我将从Java EE / Jakarta EE的角度讨论如何冒险使用Micronaut框架。 我是Java EE开发人员,因此使用诸如Eclipse MicroProfile之类的解决方案开发微服务更接近我的专业知识,但是Micronaut吸引了我的注意力,因为它具有以下功能:

    –使用Java,Groovy或Kotlin开发

    –易于通过Spock或JUnit进行测试..完全集成的测试

    –嵌入式服务器和编译时HTTP客户端

    –易于打包的Docker

    –快速启动时间,低内存消耗

    –完全React

    作为内心的企业开发人员,我的第一个想法通常是数据库,因为我编写的大多数应用程序都使用RDBMS。 我发现将Micronaut与RDBMS一起使用的示例数量很少,因此我认为为该用例创建另一个示例可能对我有用。 在此示例中,我使用PostgreSQL。 但是,大多数其他RDBMS也受支持。 本文并不意味着对安装Micronaut或利用所有许多Micronaut功能进行完整的说明。 相反,它是那些希望开始使用带有关系数据库的Micronaut的入门指南……尤其适合那些具有Java EE / Jakarta EE背景的人。

    在我的特殊情况下,我对快速完善可完全测试,可扩展和高效的微服务感兴趣。 尽管我可以使用MicroProfile或标准Java EE做到这一点,但我认为学习一些新知识并具有使用Groovy或Kotlin的能力将很有趣。 我还想将Java EE / Jakarta EE放在上面……所以我正在使用JPA处理数据。 Micronaut的许多示例都使用Groovy和GORM来实现持久性……但是我可能不会在我的任何应用程序中使用它。

    该示例是使用Apache NetBeans 9.0和Micronaut随附的命令行界面(CLI)开发的 。 该特定示例是针对Micronaut 1.0.0.M4编写的。 在这种情况下,我保持简单,只使用一个基本数据库表在PostgreSQL数据库中进行持久化。

    首先,我通过发出以下命令利用CLI创建了一个应用程序:

    mn create-app org.acme.books --features hibernate-jpa,jdbc-tomcat

    这只是在名为“ books”的目录中为我的应用程序创建了一个框架,Application.java主类将放置在org.acme.books包中。 默认情况下,应用程序支持一些基本功能,但是在这种情况下,我添加了对Tomcat连接池的支持。 通过Java Persistence API(JPA)创建数据库连接时,将利用此功能。 默认应用程序也会在支持Gradle构建系统的情况下生成。 因此,将创建一个build.gradle,即将在其中进行依赖项管理的文件。 请注意,也可以使用Apache Maven构建系统来生成应用程序,但是在Micronaut 1.0.0.M4下运行Maven项目时遇到了问题,因此在这个示例中我坚持使用Gradle。

    如果使用Apache NetBeans 9.0,则可以安装“ Groovy and Grails”和“ Gradle”插件(当前在NetBeans 8.2插件中心提供)以提供打开项目的支持。 一旦完成,就可以在NetBeans中打开项目并开始开发。 安装插件并在Apache NetBeans中打开项目后,完整的项目结构应如下图所示:

    微型船

    为了提供对PostgreSQL数据库的支持,我在build.gradle中添加了依赖项:

    compile group: 'org.postgresql', name: 'postgresql', version: '42.2.5'

    接下来,我打开了application.yml文件,并为该应用程序添加了数据源。 这是替换传统Java EE应用程序中的persistence.xml的文件。 同样,通过此文件添加了JPA支持,指示哪个包包括实体类以及Hibernate的配置。 端口8080也已设置,因为默认情况下Micronaut将选择一个随机端口来启动服务器。 application.xml的完整资源如下:

    micronaut:
    
    application:
    
    name: books
    
    #Uncomment to set server port
    
    server:
    
    port: 8080
    
    ---
    
    datasources:
    
    default:
    
    url: jdbc:postgresql://localhost/postgres
    
    username: postgres
    
    password: yourpassword
    
    driverClassName: org.postgresql.Driver
    
    connectionTimeout: 4000
    
    jpa:
    
    default:
    
    packages-to-scan:
    
    - 'org.acme.domain'
    
    properties:
    
    hibernate:
    
    hbm2ddl:
    
    auto: update
    
    show_sql: true

    现在配置已不复存在,我可以开始有趣的部分了……开发。 在此示例中,我创建了一项基本服务,该服务允许创建,读取,更新或删除BOOK表中的记录。 org.acme包中自动生成的Application类,用于启动服务。

    package org.acme;
    
    import io.micronaut.runtime.Micronaut;
    
    public class Application {
    
    public static void main(String[] args) {
    
    Micronaut.run(Application.class);
    
    }
    
    }

    要开始开发,请在应用程序内创建两个用于组织源代码的软件包。 首先,创建org.acme.domain,它将包含实体类。 接下来,创建org.acme.book,其中将包含实现类。 在org.acme.domain包中创建一个Book.java类,它将是包含数据库标准JPA映射的实体类。 在这种情况下,请注意,我将java.time.LocalDate用于日期字段,并将数据库序列生成器用于主键填充。 来源如下:

    package org.acme.domain;
    
    import java.time.LocalDate;
    
    import javax.persistence.Column;
    
    import javax.persistence.Entity;
    
    import javax.persistence.GeneratedValue;
    
    import javax.persistence.GenerationType;
    
    import javax.persistence.Id;
    
    import javax.persistence.SequenceGenerator;
    
    import javax.persistence.Table;
    
    import javax.validation.constraints.NotNull;
    
    /**
    
    * JPA Mappings for the BOOK database table.
    
    */
    
    @Entity
    
    @Table(name="BOOK")
    
    public class Book {
    
    @Id
    
    @GeneratedValue(strategy=GenerationType.SEQUENCE,
    
    generator="book_generator")
    
    @SequenceGenerator(name="book_generator",sequenceName="book_s", allocationSize=1)
    
    private Long id;
    
    @Column(name="PUBLISH_DATE")
    
    @NotNull
    
    private LocalDate publishDate;
    
    @Column(name="TITLE")
    
    @NotNull
    
    private String title;
    
    @Column(name="AUTHOR_FIRST")
    
    @NotNull
    
    private String authorFirst;
    
    @Column(name="AUTHOR_LAST")
    
    @NotNull
    
    private String authorLast;
    
    private Long pages;
    
    public Book(){}
    
    public Book(@NotNull Long id, @NotNull LocalDate publishDate, @NotNull String title, String authorFirst, String authorLast, Long pages){
    
    this.id = id;
    
    this.publishDate = publishDate;
    
    this.title = title;
    
    this.authorFirst = authorFirst;
    
    this.authorLast = authorLast;
    
    this.pages = pages;
    
    }
    
    public Book(@NotNull LocalDate publishDate, @NotNull String title, String authorFirst, String authorLast, Long pages){
    
    this.publishDate = publishDate;
    
    this.title = title;
    
    this.authorFirst = authorFirst;
    
    this.authorLast = authorLast;
    
    this.pages = pages;
    
    }
    
    /**
    
    * @return the id
    
    */
    
    public Long getId() {
    
    return id;
    
    }
    
    /**
    
    * @param id the id to set
    
    */
    
    public void setId(Long id) {
    
    this.id = id;
    
    }
    
    /**
    
    * @return the publishDate
    
    */
    
    public LocalDate getPublishDate() {
    
    return publishDate;
    
    }
    
    /**
    
    * @param publishDate the publishDate to set
    
    */
    
    public void setPublishDate(LocalDate publishDate) {
    
    this.publishDate = publishDate;
    
    }
    
    /**
    
    * @return the title
    
    */
    
    public String getTitle() {
    
    return title;
    
    }
    
    /**
    
    * @param title the title to set
    
    */
    
    public void setTitle(String title) {
    
    this.title = title;
    
    }
    
    /**
    
    * @return the authorFirst
    
    */
    
    public String getAuthorFirst() {
    
    return authorFirst;
    
    }
    
    /**
    
    * @param authorFirst the authorFirst to set
    
    */
    
    public void setAuthorFirst(String authorFirst) {
    
    this.authorFirst = authorFirst;
    
    }
    
    /**
    
    * @return the authorLast
    
    */
    
    public String getAuthorLast() {
    
    return authorLast;
    
    }
    
    /**
    
    * @param authorLast the authorLast to set
    
    */
    
    public void setAuthorLast(String authorLast) {
    
    this.authorLast = authorLast;
    
    }
    
    /**
    
    * @return the pages
    
    */
    
    public Long getPages() {
    
    return pages;
    
    }
    
    /**
    
    * @param pages the pages to set
    
    */
    
    public void setPages(Long pages) {
    
    this.pages = pages;
    
    }
    
    @Override
    
    public String toString() {
    
    return "Book{" +
    
    "id=" + id +
    
    ", publishDate='" + publishDate + '\'' +
    
    ", title='" + title + '\'' +
    
    ", authorFirst='" + authorFirst + '\'' +
    
    ", authorLast='" + authorLast + '\'' +
    
    ", pages='" + pages +
    
    '}';
    
    }
    
    }

    在Micronaut应用程序中,需要将HTTP请求和响应封装在Serializable类中进行处理,因此,生成一些简单的“纯旧Java对象”(POJO)来封装将在数据库操作中使用的数据是有意义的。 在同一个org.acme.domain包中,我创建了两个此类,BookSaveOperation.java和BookUpdateOperation.java。 这些类将定义将数据从HTTP请求传递到控制器类所需的字段。 BookSaveOperation.java的源如下(有关完整源,请参见GitHub存储库):

    package org.acme.domain;
    
    import java.time.LocalDate;
    
    import javax.validation.constraints.NotBlank;
    
    import javax.validation.constraints.NotNull;
    
    /**
    
    *
    
    * @author Josh Juneau
    
    */
    
    public class BookSaveOperation implements java.io.Serializable {
    
    @NotNull
    
    private LocalDate publishDate;
    
    @NotNull
    
    @NotBlank
    
    private String title;
    
    @NotNull
    
    @NotBlank
    
    private String authorFirst;
    
    @NotNull
    
    @NotBlank
    
    private String authorLast;
    
    private Long pages;
    
    public BookSaveOperation(){}
    
    public BookSaveOperation(LocalDate publishDate, String title,
    
    String authorFirst, String authorLast, Long pages){
    
    this.publishDate = publishDate;
    
    this.title = title;
    
    this.authorFirst = authorFirst;
    
    this.authorLast = authorLast;
    
    this.pages = pages;
    
    }
    
    // ...
    
    // getters and setters
    
    // ...
    
    }

    应用程序业务逻辑发生在一个类中,该类非常类似于EJB或DAO实现,并且该类必须实现定义了每个业务逻辑方法的接口。 在这种情况下,我创建了一个接口org.acme.book.BookRepository.java,并定义了一些标准的操作方法:

    package org.acme.book;
    
    import java.time.LocalDate;
    
    import java.util.List;
    
    import java.util.Optional;
    
    import org.acme.domain.Book;
    
    /**
    
    *
    
    */
    
    public interface BookRepository {
    
    Book save(LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages);
    
    Optional<Book> findById(Long id);
    
    void deleteById(Long id);
    
    List<Book> findAll();
    
    int update(Long id, LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages);
    
    }

    接下来,在名为org.acme.book.BookRepositoryImpl.java的类中实现该接口,并注释为@Singleton。 由于这是将实现业务逻辑的类,因此请注入PersistenceContext,该持久性上下文提供将用于执行数据库操作的JPA EntityManager。 只需实现BookRepository界面中概述的每个操作,并使用@Transactional(io.micronaut.spring.tx.annotation.Transactional)进行标记,就意味着仅对那些不会修改任何数据的方法进行只读。 BookRepositoryImpl.java的源如下:

    package org.acme.book;
    
    import io.micronaut.configuration.hibernate.jpa.scope.CurrentSession;
    
    import io.micronaut.spring.tx.annotation.Transactional;
    
    import java.time.LocalDate;
    
    import java.util.List;
    
    import java.util.Optional;
    
    import javax.inject.Singleton;
    
    import javax.persistence.EntityManager;
    
    import javax.persistence.PersistenceContext;
    
    import org.acme.domain.Book;
    
    /**
    
    * Business logic for the service.
    
    */
    
    @Singleton
    
    public class BookRepositoryImpl implements BookRepository {
    
    @PersistenceContext
    
    private EntityManager entityManager;
    
    public BookRepositoryImpl(@CurrentSession EntityManager entityManager) {
    
    this.entityManager = entityManager;
    
    }
    
    @Override
    
    @Transactional
    
    public Book save(LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages) {
    
    Book book = new Book(publishDate, title, authorFirst, authorLast, pages);
    
    entityManager.persist(book);
    
    return book;
    
    }
    
    @Override
    
    @Transactional(readOnly = true)
    
    public Optional<Book> findById(Long id) {
    
    return Optional.ofNullable(entityManager.find(Book.class, id));
    
    }
    
    @Transactional(readOnly = true)
    
    public List<Book> findAll() {
    
    return entityManager
    
    .createQuery("SELECT b FROM Book b", Book.class)
    
    .getResultList();
    
    }
    
    @Override
    
    @Transactional
    
    public int update(Long id, LocalDate publishDate, String title, String authorFirst, String authorLast, Long pages) {
    
    return entityManager.createQuery("UPDATE Book b SET publishDate = :publishDate, title = :title, " +
    
    "authorFirst = :authorFirst, authorLast = :authorLast, pages = :pages where id = :id")
    
    .setParameter("publishDate", publishDate)
    
    .setParameter("title", title)
    
    .setParameter("authorFirst", authorFirst)
    
    .setParameter("authorLast", authorLast)
    
    .setParameter("pages", pages)
    
    .setParameter("id", id)
    
    .executeUpdate();
    
    }
    
    @Override
    
    @Transactional
    
    public void deleteById(Long id) {
    
    findById(id).ifPresent(book -> entityManager.remove(book));
    
    }
    
    }

    为了从Java EE角度解释Micronaut应用程序基础结构,我将比较该实现与一个简单的JAX-RS应用程序。 Micronaut利用io.micronaut.http.annotation.Controller类来执行服务的请求-响应处理。 这非常类似于JAX-RS控制器类,但有一些细微的差异。 这让我想起了Eclipse Krazo项目或Java EE的MVC 1.0。 例如,Micronaut而不是使用JAX-RS注释javax.ws.rs.GET,javax.ws.rs.POST或javax.ws.rs.Path注释方法,而是使用io.micronaut.http.annotation.Get和io.micronaut.http.annotation.Post等。 每个方法的URI路径都可以通过@ Get,@ Post,@ Put,@ Delete批注直接声明。 每个控制器类都将实现服务的功能并处理请求-响应生命周期。 通过@Inject批注或构造函数注入将用于持久性的业务逻辑(包含在BookRepositoryImpl类中)注入到控制器类中。 在此示例的源代码中,使用了构造函数注入。

    package org.acme.book;
    
    import org.acme.domain.Book;
    
    import io.micronaut.http.HttpHeaders;
    
    import io.micronaut.http.HttpResponse;
    
    import io.micronaut.http.annotation.Body;
    
    import io.micronaut.http.annotation.Controller;
    
    import io.micronaut.http.annotation.Delete;
    
    import io.micronaut.http.annotation.Get;
    
    import io.micronaut.http.annotation.Post;
    
    import io.micronaut.http.annotation.Put;
    
    import io.micronaut.validation.Validated;
    
    import javax.validation.Valid;
    
    import java.net.URI;
    
    import java.util.List;
    
    import org.acme.domain.BookSaveOperation;
    
    import org.acme.domain.BookUpdateOperation;
    
    @Validated
    
    @Controller("/books")
    
    public class BookController {
    
    protected final BookRepository bookRepository;
    
    public BookController(BookRepository bookRepository) {
    
    this.bookRepository = bookRepository;
    
    }
    
    @Get("/")
    
    public List<Book> list() {
    
    return bookRepository.findAll();
    
    }
    
    @Put("/")
    
    public HttpResponse update(@Body @Valid BookUpdateOperation operation) {
    
    bookRepository.update(operation.getId(), operation.getPublishDate(),
    
    operation.getTitle(), operation.getAuthorFirst(), operation.getAuthorLast(), operation.getPages());
    
    return HttpResponse.noContent().header(HttpHeaders.LOCATION, location(operation.getId()).getPath());
    
    }
    
    @Get("/{id}")
    
    Book show(Long id) {
    
    return bookRepository
    
    .findById(id)
    
    .orElse(null);
    
    }
    
    @Delete("/{id}")
    
    HttpResponse delete(Long id) {
    
    bookRepository.deleteById(id);
    
    return HttpResponse.noContent();
    
    }
    
    @Post("/")
    
    HttpResponse<Book> save(@Body @Valid BookSaveOperation operation) {
    
    Book book = bookRepository.save(operation.getPublishDate(), operation.getTitle(),
    
    operation.getAuthorFirst(), operation.getAuthorLast(), operation.getPages());
    
    return HttpResponse
    
    .created(book)
    
    .headers(headers -> headers.location(location(book)));
    
    }
    
    protected URI location(Book book) {
    
    return location(book.getId());
    
    }
    
    protected URI location(Long id) {
    
    return URI.create("/books/" + id);
    
    }
    
    }

    测试应用

    Micronaut可以使用Spock或JUnit以及嵌入式服务器轻松进行测试,从而可以轻松地为每个控制器创建测试。 在这种情况下,我利用JUnit来测试应用程序。 我在名为org.acme.BookControllerTest的项目的测试文件夹内创建了一个测试类。

    package org.acme;
    
    import io.micronaut.context.ApplicationContext;
    
    import io.micronaut.core.type.Argument;
    
    import io.micronaut.http.HttpHeaders;
    
    import io.micronaut.http.HttpRequest;
    
    import io.micronaut.http.HttpResponse;
    
    import io.micronaut.http.HttpStatus;
    
    import io.micronaut.http.client.HttpClient;
    
    import io.micronaut.runtime.server.EmbeddedServer;
    
    import java.time.LocalDate;
    
    import java.util.ArrayList;
    
    import java.util.List;
    
    import org.acme.domain.Book;
    
    import org.acme.domain.BookSaveOperation;
    
    import org.acme.domain.BookUpdateOperation;
    
    import org.junit.AfterClass;
    
    import static org.junit.Assert.assertEquals;
    
    import org.junit.BeforeClass;
    
    import org.junit.Test;
    
    /**
    
    * Test cases for BookController
    
    */
    
    public class BookControllerTest {
    
    private static EmbeddedServer server;
    
    private static HttpClient client;
    
    private  Book book;
    
    HttpRequest request;
    
    HttpResponse response;
    
    Long id;
    
    List<Long> bookIds = new ArrayList<>();
    
    @BeforeClass
    
    public static void setupServer() {
    
    server = ApplicationContext.run(EmbeddedServer.class);
    
    client = server.getApplicationContext().createBean(HttpClient.class, server.getURL());
    
    }
    
    @AfterClass
    
    public static void stopServer() {
    
    if (server != null) {
    
    server.stop();
    
    }
    
    if (client != null) {
    
    client.stop();
    
    }
    
    }
    
    @Test
    
    public void testInsertBooks() {
    
    request = HttpRequest.POST("/books", new BookSaveOperation(LocalDate.now(), "Java EE 8 Recipes", "Josh", "Juneau", new Long(750)));
    
    response = client.toBlocking().exchange(request);
    
    assertEquals(HttpStatus.CREATED, response.getStatus());
    
    request = HttpRequest.POST("/books", new BookSaveOperation(LocalDate.now(), "Java 9 Recipes", "Josh", "Juneau", new Long(600)));
    
    response = client.toBlocking().exchange(request);
    
    id = entityId(response, "/books/");
    
    assertEquals(HttpStatus.CREATED, response.getStatus());
    
    }
    
    @Test
    
    public void testBookRetrieve() {
    
    request = HttpRequest.GET("/books");
    
    List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));
    
    // Populate a book instance for later
    
    for(Book b:books){
    
    book = b;
    
    }
    
    assertEquals(2, books.size());
    
    }
    
    @Test
    
    public void testBookOperations() {
    
    request = HttpRequest.GET("/books");
    
    List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));
    
    // Populate a book instance for later
    
    for(Book b:books){
    
    book = b;
    
    }
    
    request = HttpRequest.PUT("/books/", new BookUpdateOperation(book.getId(),
    
    book.getPublishDate(),
    
    "Java 10 Recipes",
    
    book.getAuthorFirst(),
    
    book.getAuthorLast(),
    
    book.getPages()));
    
    response = client.toBlocking().exchange(request);
    
    assertEquals(HttpStatus.NO_CONTENT, response.getStatus());
    
    request = HttpRequest.GET("/books/" + book.getId());
    
    book = client.toBlocking().retrieve(request, Book.class);
    
    assertEquals("Java 10 Recipes", book.getTitle());
    
    testDelete();
    
    }
    
    public void testDelete(){
    
    request = HttpRequest.GET("/books");
    
    List<Book> books = client.toBlocking().retrieve(request, Argument.of(List.class, Book.class));
    
    // Populate a book instance for later
    
    for(Book b:books){
    
    request = HttpRequest.DELETE("/books/" + b.getId());
    
    response = client.toBlocking().exchange(request);
    
    assertEquals(HttpStatus.NO_CONTENT, response.getStatus());
    
    }
    
    }
    
    Long entityId(HttpResponse response, String path) {
    
    String value = response.header(HttpHeaders.LOCATION);
    
    if (value == null) {
    
    return null;
    
    }
    
    int index = value.indexOf(path);
    
    if (index != -1) {
    
    return Long.valueOf(value.substring(index + path.length()));
    
    }
    
    return null;
    
    }
    
    }

    考试逻辑导论

    在运行@BeforeClass的方法中,将创建HTTP服务器和客户端。 同样,测试完成执行后,将调用以@AfterClass注释的方法,如果服务器正在运行,它将停止服务器。

    在textInsertBooks()方法中,通过将填充有数据的新BookSaveOperation对象传递给可通过@Post命名的“ / books”路径访问的服务,来创建两个新的书记录。 在这种情况下,将调用控制器方法BookController.save()。 看一下save()方法,您可以看到该方法只是将BookSaveOperation的内容传递给BookRepository.save()业务方法(利用该接口),从而持久化对象。 最后,返回HttpResponse。

    testBookRetrieve()方法调用可通过包含@Get名称的“ / books”路径使用的服务。 依次调用BookController.list()方法,该方法在BookRepository上执行findAll(),返回Book对象的List。

    testBookOperations()方法负责对记录进行更新。 首先,从BookController中检索Book对象的列表,然后通过使用要更新的内容填充BookUpdateOperation对象,通过BookController.update()方法更新其中一本书。

    **请记住,BookSaveOperation.java和BookUpdateOperation.java对象只是用于移动数据的POJO。

    最后,调用testDelete()方法,该方法遍历Book对象的List,通过对“ / books”路径的服务调用来调用BookController.delete()方法,并调用指定为@Delete的方法。

    要执行测试,只需在NetBeans中右键单击该项目并选择“ Test”,或使用命令行使用以下命令来调用

    ./gradlew test

    如果尚未创建数据库表,则将为您生成该表。 请注意,您可能需要根据环境修改application.yml中的数据库配置。

    运行服务

    Micronaut是独立的,允许使用基于Netty构建的嵌入式服务器执行服务。 可以通过右键单击Apache NetBeans中的项目并选择“运行”来完成。 您也可以转到命令行并使用以下命令进行调用:

    ./gradlew run

    您应该在终端或Apache NetBeans输出面板的输出中看到托管服务器的URL。

    摘要

    作为Java EE开发人员,我不得不说Micronaut确实有不同的开发方法。 它与Spring Boot或Grails并没有太大的区别,但是又有足够的区别,以至于我花了一些时间找到解决方法。 最后,我发现它是一个易于使用的框架,它具有快速开发服务或计划任务的巨大潜力,同时仍然利用Java EE / Jakarta EE的一些概念。

    我还没有使用很多功能,例如通过Micronaut框架创建计划任务,以及使用Groovy或Kotlin而不是Java进行开发。 我希望在以后的文章中继续介绍有关Java EE和Jakarta EE开发人员的更多信息,他们有兴趣开始使用Micronaut。

    GitHub项目:https://github.com/juneau001/micronaut-books

    翻译自: https://www.javacodegeeks.com/2018/09/micronaut-for-java-ee-jakarta-ee-developers.html

    jakarta ee

    展开全文
  • Apress源代码 该存储库Daniel Andres Pelaez Lopez进行(Apress,2020年)。 使用绿色按钮将文件下载为zip格式,或使用Git将存储库克隆到您的计算机上。 发行版 版本v1.0对应于已出版书籍中的代码,没有更正或更新...
  • Apress源代码 该存储库与Luciano Manelli和Giulio Zambon撰写的使用(Apress,2020年)。 使用绿色按钮将文件下载为zip格式,或使用Git将存储库克隆到您的计算机上。 发行版 版本v1.0对应于已出版书籍中的代码,...
  • 从 JavaEE 到 JakartaEE

    2021-11-08 03:30:54
    platform jakartaee8 jakartaee9 jakartaee-specifications jakarta.ee jakarta9 Maven GAV <dependency> <groupId>jakarta.platformgroupId> <artifactId>jakarta.jakartaee-apiartifactId> <version>8.0.0version>...

    JavaEE

    • javaEE 5 : https://jcp.org/en/jsr/detail?id=244
    • https://jcp.org/en/jsr/detail?id=313
    • javaEE6 : https://jcp.org/en/jsr/detail?id=316
    • JavaTM Persistence 2.0 : https://jcp.org/en/jsr/detail?id=317
    • Java Persistence 2.2 : https://jcp.org/en/jsr/detail?id=338
    • Java EE 7 : https://jcp.org/en/jsr/detail?id=342
    • Servlet4.0 : https://jcp.org/en/jsr/detail?id=369
    • Java EE Security API : https://jcp.org/en/jsr/detail?id=375
    • JavaEE8规范 : https://jcp.org/en/jsr/detail?id=366
      • https://download.oracle.com/otn-pub/jcp/java_ee-8-final-eval-spec/JavaEE_Platform_Spec.pdf



    • Maven GAV : https://mvnrepository.com/artifact/javax/javaee-api
      在这里插入图片描述
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>8.0.1</version>
    </dependency>
    

    JakartaEE


    • Maven GAV
      在这里插入图片描述
    <dependency>
        <groupId>jakarta.platform</groupId>
        <artifactId>jakarta.jakartaee-api</artifactId>
        <version>8.0.0</version>
    </dependency>
    

    版本 8.0.0 依然使用 javax.* 包空间,兼容 javaee8;

    在这里插入图片描述


    版本 9.0.0 包空间改为 jakarta.* 不再向前兼容;

    • Tomcat10.x 开始适配 jakarta 包空间
    • Spring 6 和 SpringBoot3.x 可能会进行适配
    • Eclipse 的 GlassFish(JavaEE服务器)已适配
    • RedHat 的 WildFly(JBoss的开源版本 JavaEE服务器) 已计划适配

    在这里插入图片描述

    参考文档

    https://mp.weixin.qq.com/s/bWVTBRwERXV2adzL00LT-A

    Servlet

    展开全文
  • Jakarta EE 2020战果总结

    2021-01-14 17:20:44
    从Eclipse基金接过java EE的接力棒已有两年多了,由于Oracle拒绝交出javax名称空间的使用权, Eclipse基金只能新建一个名称空间Jakarta. 从官方的规范来看还是战果累累。Eclipse基金现在完成了Jakarta8,9的release。...
  • 我们也为JavaFX 13感到兴奋,但是现在让我们专注于Jakarta EE 8的企业Java。因此,事不宜迟,让我们开始与Mike Milinkovich一起庆祝Jakarta EE 8的发布! JAXenter:您好,感谢您抽出宝贵时间接受本采访。 经过几...
  • jakarta ee 您是否有兴趣帮助Jakarta EE向前发展? 我也是。我想提供一些详细信息,以帮助有兴趣入门的人。 第1步: 开始捐款的第一步是签署Eclipse Foundation Committer and Contributor Agreement(ECA): ...
  • jakarta ee 9 Jakarta EE的名称已经存在了一个多月,即使Mike Milinkovich在他的博客文章“ The Name Is…”中很好地解释了名称和概念,但对于它们之间的关系仍然有些困惑,我也提出了疑问每当出现主题时,都围绕它...
  • jakarta ee 自Oracle在JavaOne 2017宣布将Java™EE转移到Eclipse Foundation以来已有一年多了。此后,发生了很多事情: Java™EE 8 API和实现项目已在EE4J下建立 。 Eclipse GlassFish 5.1 即将发布 。 全新...
  • jakarta ee Eclipse基金会选择Jakarta EE作为该技术的新名称,该技术以前称为Java EE。 去年9月, Eclipse基金会宣布Oracle将把Java平台企业版( Java EE )移交给Eclipse,以促进行业范围内的合作并推动该技术的...
  • 2021年Jakarta EE开发者调查结果出炉
  • 原标题:Java EE 正式更名为 Jakarta EEEclipse基金会社区已将Java EE改名为Jakarta EE。这个名称来自Apache的一个早期开源项目:Jakarta Project。Eclipse基金会的执行董事迈克•米林科维奇(Mike Milinkovich)在博...
  • 根据 官方网站 https://jakarta.ee/compatibility/#tab-9_1提供的兼容列表,中国已经有四家公司的四个产品符合Jakarta EE 9.1规范。 此外 两个比较出名的开源运行环境也在兼容列表了。这两个兼容产品为Eclipse ...
  • jakarta ee_深入了解Jakarta EE 9发布计划

    千次阅读 2020-06-06 16:05:21
    Jakarta EE社区也是如此-在过去几周的圣诞节休息之后,现在又开始着手实现2020年的宏伟目标,即发布Jakarta EE 9。 大爆炸 正如最近报道的那样,Oracle是第一个在去年年底开始为Jakarta EE 9制定自己的计划和想法...
  • Payara Micro 5上的Jakarta EE 8的Microj模板 一个Microj模板,用于在Payara Micro 5上运行带有Java 11的Jakarta EE 8微服务。 维护者 M.-Leander Reimer(@lreimer), -leander.reimer 执照 该软件是根据MIT开源...
  • 回顾下JAVA那些易混淆的概念,包括 JVM/JRE/JDK,openJDK/oracleJDK,以及 JAVA SE/JAVA EE/Jakarta EE
  • 说起JavaEE,很多人不陌生,从J2EE到JavaEE到现在的JakartaEE,可以说见证了好几个时代,作为JavaEE的核心标准之一的EJB,的从EJB2的笨重,到EJB3的轻盈,虽然一直在进步,但是因为EJB3的生不逢时,让其面对Spring再...
  • 本月初,Jakarta EE社区成员被邀请参加Jakarta EE社区之声文档 ,该文档重点关注Jakarta EE规范的技术创新。 本文档中的内容反映了参与者对他们希望贡献时间的领域的个人观点。 但是,必须提及的是,它们并不代表...
  • Jakarta EE 9里程碑发布会总结2017年9月 Oracle 将 Java EE 移交给 Eclipse 基金会管理。2018年 Java EE 经过社区投票,更名为 Jakar...
  • Jakarta EE中的规范范围

    2020-06-08 04:25:39
    例如,我们可能会考虑将Jakarta EE Stable API的项目范围更改为简单的内容(请注意,我正在猜测将来的新项目名称): Jakarta EE稳定API提供了稳定的(旧式)Jakarta EE规范和相关工件的源头,这些规范和相关工件...
  • 如果您错过了新闻, Oracle将向Eclipse基金会捐赠Java EE规范 。 这项决策在规范过程中经历了相当长时间的休眠,在此过程中,人们理所当然地怀疑Oracle对Java EE失去了战略兴趣。 起初,Java EE和更广泛的Java社区很...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,527
精华内容 2,610
关键字:

Jakarta ee