JakaratEE dünyasında EJB, Hibernate ve JSP beraber nasıl kullanılabilir?

Yakın zamanda java web dünyasında göreceğimiz bir gelişme var. Bu da "javax" namespace 'lerinin "jakarta" şeklinde değişmesi. Konunun detayını burada bulabilirsiniz. Bu değişim ile birlikte eskiden JavaEE olan platform JakartaEE (versiyon 9) olacak, Spring framework altyapısında kullandığı paket isimlerini 6.0 versiyonunda güncelleyecek, Hibernate veya Jersey gibi kütüphaneler ise jakarta.persistence veya jakarta.ws.rs gibi paketlere dönüşecek. Bu dönüşüm belki de yenilenme zamanı gelmiş eski EJB (enterprise java beans) projeleri için de bir işarettir diye düşünüyorum. Bu yazıda spring framework kullanmadan JavaEE dünyasında JakartaEE 9, EJB, Hibernate ve JSP teknolojileri nasıl bir araya getirilebilir sorusunu bir örnek proje ile göstereceğim. Tabi ki projeyi maven ile geliştirdim. Yaptığım demo proje sadece bir "book" nesnesini veritabanına yazıyor ve bu nesneleri JSP sayfasında listeliyor.

Kafa karışıklığını gidermek adına küçük bir açıklama yapayım. Günümüzde spring boot ve thymeleaf ile zaten çok fonksiyonlu web uygulamaları geliştirmek mümkün. Yakın zamanda o dünyada hibernate ve benzeri kütüphaneler ve entegrasyonlarla beraber jakarta isimlerini görmeye başlayacağız. Peki ben neden spring framework yerine EJB ile örnek yapıyorum? Çünkü günümüzde hala eski ve karmaşık java teknolojileri ile yazılmış, maven bile kullanmayan web ugyulamaları var. Bunların yenilenmesi demek java ekosisteminde spring gibi bir teknoljiye geçilmesi demek ise bu çok büyük bir yük oluşturacaktır. Teknoloji değiştirmektense EJB dünyasından devam edip altyapı güncellemek ve hal-ü hazırda var bulunan bilgi birikimlerini değerlendirmek mantıklı olacaktır. Hazırladığım demo proje güncel kütüphaneleri kullanıyor, gerekli minimum özellikleri sağlıyor ve kafa karışıklığını da gideriyor. Özetle, eski bir Java web uygulamanız mı var? Yenilemek mi istiyorsunuz? Bu blog yazısından başlayabilirsiniz. Aksi takdirde "jakarta, ejb, hibernate, jsp" dörtlüsünü 2022 yılı ocak ayında google 'da aradığınızda fazla sonuç veya örnek çıkmıyor :)

Bu demo projenin güncel kodlarını github 'da bulabilirsiniz. Bu yazıda çoğunlukla kodların önemli kısımlarını aktaracağım. Bu projeyi anlayabilmek ve çalıştırabilmek için bazı teknolojiler konusunda bilginizin olması ve bilgisayarınızda bazı uygulamaların kurulu olması gerekiyor. Alışveriş listemiz aşağıdaki gibi.

• JavaEE, Servlet, Maven ve JSP bilgisi
• java 13 veya Java 17 'nin bilgisayarınızda kurulu olması
• Eclipse veya Intellij tercih ederseniz bir IDE
• Eğer eclipse kullanıyorsanız Lombok için bir plugin kurmanız da gerekecektir
• Postgresql veya tercih ettiğiniz başka bir RDBMS teknolojisi

Projenin oluşturulması

Bu projeyi sıfırdan oluşturmak isterseniz bir maven projesini aşağıdaki resimdeki gibi maven-archetype-webapp archetype 'ı ile oluşturabilirsiniz. Bu şekilde bir web uygulamasının gereklilikleri olan webapp ve WEB-INF klasörleri ve web.xml dosyası da oluşmuş olacaktır. Spring boot gibi hazır bir yapı kullanamadığımız ve günümüzde jakartaee 9, hibernate ve jsp kullanan güncel ve sade bir archetype bulamadığımız için bu noktadan başlamak gerekiyor.

Proje oluşturulduktan sonra temelde aşağıdaki adımları izlememiz gerekiyor.

• Pom.xml dosyasında jakartaee, hibernate ve JSP için gerekli bağımlılıkları eklemek
• web.xml dosyasında servlet ve mapping ayarı yapmak
• Bu servlet için bir jakarta servlet extension sınıfı hazırlamak
• Bu archetype 'da src/main klasöründe java klasörü oluşmayabiliyor, kontrol edip yoksa oluşturmak
• Hibernate için SessionFactory oluşturmak
• Yine hibernate için resources klasörü içinde hibernate.cfg.xml dosyasını oluşturmak

Bu silsileyi takip edebilmeniz için önemli kodları göstereyim.

pom.xml dosyası ve minimum gereksinimler

Pom.xml dosyasında javaee için JakartaEE 9, Hibernate için jakarta olan versiyonu hibernate core 6, JSP için jakarta.servlet.jstl 2.0.0 en önemli bağımlılıklarımız olarak karşımıza çıkıyor. Bunların yanında postgresql tabi ki hibernate tarafından veritabanına bağlanmak için kullanılacak driver oluyor. Bir de eclipse 'in jsp sayfalarında mızırdanmaması için jakarta.servlet bağımlılığı var ama dikkat ederseniz provided yani zaten sunucumuzda var bu bağımlılık. Eclipse bunu henüz bilmiyor :)

			
<dependencies>
	<!-- this is the new jakarta EE runtime, renamed from javax to jakarta in the version 9 -->
	<dependency>
		<groupId>jakarta.platform</groupId>
		<artifactId>jakarta.jakartaee-api</artifactId>
		<version>9.1.0</version>
		<scope>provided</scope>
	</dependency>
	<!-- This is here to shut up the eclipse complaining about no "javax.servlet implementation found on classpath" in JSP files -->
	<!-- This is already in TomEE, so it is provided and not included in the output war file -->
	<dependency>
		<groupId>jakarta.servlet</groupId>
		<artifactId>jakarta.servlet-api</artifactId>
		<version>5.0.0</version>
		<scope>provided</scope>
	</dependency>
	<!-- This is important !! You need the java tag library processing in your JSP files -->
	<!-- This is also not javax, it is jakarta from now on -->
	<dependency>
		<groupId>jakarta.servlet.jsp.jstl</groupId>
		<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
		<version>2.0.0</version>
	</dependency>
	<!-- This one prevents the JSP files complaining about JSTL library not found, not sure it is mandatory though -->
	<dependency>
		<groupId>org.apache.taglibs</groupId>
		<artifactId>taglibs-standard-impl</artifactId>
		<version>1.2.5</version>
		<scope>runtime</scope>
	</dependency>
	<!-- Hibernate 6 is the jakarta package version, not javax.persistance anymore, it is jakarta.persistance -->
	<dependency>
		<groupId>org.hibernate.orm</groupId>
		<artifactId>hibernate-core</artifactId>
		<version>6.0.0.Beta3</version>
	</dependency>
	<dependency>
		<groupId>org.postgresql</groupId>
		<artifactId>postgresql</artifactId>
		<version>42.3.1</version>
	</dependency>
</dependencies>

<build>
	<pluginManagement>
		<plugins>
			<plugin>
				<!-- You can use EAR plugin to create a modular project but it would becoma a monolithic project -->
				<!-- Why create a monolithic project in 2022 ? -->
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<version>3.3.1</version>
			</plugin>
		</plugins>
	</pluginManagement>
</build>
			
		

Bu uygulamayı TomEE veya jboss veya glassfish gibi bir EJB container sunucusunda çalıştıracağız. Çünkü bu sunucular EJB spesifikasyonlarının implementasyonları. Evet cümle uydurulmuş gibi geliyor kulağa ama dependency injection dediğimiz kavram enterprise java bean 'leri ile yapılmak istenirse tomcat yerine EJB container özellikleri taşıyan bir sunucu gerekiyor. Bu da facia bir cümle oldu kusura bakmayın artık :)

Pom dosyasında maven-war-plugin 'de bulunuyor. Bir parent pom kullanmadığımız için uygulama compile edildiğinde üreteceği çıktı formatını belirtiyoruz aslında. Burada EAR kullanılabilir belki. Küçük EJB projelerinin yani war dosyalarının bir birleşimi olarak enterprise archive çıktısı üretebilirsiniz. Fakat 2022 yılında neden monolitik proje üretelim ki? Sırada xml konfigürasyonları geliyor.

Web.xml ve hibernate.cfg.xml dosyaları

Web.xml dosyasında olmazsa olmaz bir servlet tanımımız ve bu servlet 'e ulaşacak mapping 'lerimiz var doğal olarak. Bu dosyada olağan dışı pek bir bilgi yok eğer web uyglamalarına biraz aşina iseniz. Buradaki tek gariplik demo projemde "books" isimli bir klasöre kitap model 'i (yada entity 'si diyebiliriz) ile ilgili sayfaları koymuş olmam. Bu yüzden mapping bilgilerini sayfalara tek tek vermek zorunda kaldım. (/books/*) şeklinde bir ifade yazdığımda jsp sayfalarına yönlendirmek yerine sonsuz döngüye giriyordu. Bu servlet için yazdığım "BookServlet" class 'ını aşağıda inceleyeceğiz.

			
<web-app>
	<display-name>Archetype Created Web Application</display-name>
	<!-- I don't have BookServlet-servlet.xml in this project like in spring framework -->
	<!-- It is possible to create an ejb-jar.xml file, but i think it is old school -->
	<servlet>
		<servlet-name>BookServlet</servlet-name>
		<display-name>BookServlet</display-name>
		<description>Book servlet</description>
		<servlet-class>com.numankaraaslan.jakartaejb.servlet.BookServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>BookServlet</servlet-name>
		<url-pattern>/book/addbook</url-pattern>
	</servlet-mapping>
	<servlet-mapping>
		<servlet-name>BookServlet</servlet-name>
		<url-pattern>/book/books</url-pattern>
	</servlet-mapping>
</web-app>
			
		

Bu aşamada projede bean 'lerin nerede oluşturulacağını soruyor olabilirsiniz. Spring framework 'de applicationcontext.xml veya beans.xml veya servlet.xml gibi dosyalarımız vardı. Burada da ejb-jar.xml dosyası bulunabiliyor bildiğim kadarıyla. Fakat ben bean 'leri bir sınıf yardımı ile üreteceğim. Örnek bir ejb-jar.xml dosyasına buradan ulaşabilirsiniz.

Projede bir xml konfigürasyonumuz daha var o da hibernate.cfg.xml dosyası. Bu dosyada da hibernate 'in kullanacağı ayarlar set edilir. Ayarlar içerisinde hibernate.dialect ve hibernate.hbm2ddl.auto özellikle önemlidir. Dialect bilgisi kullandığınız postgresql sürümü ile uyumlu olmalıdır. ddlauto ise veritabanında tablolarınızı uygulama açılırken otomatik olarak oluşturacaktır. Transaction yönetimini kendimiz yapacağız, JTA veya spring data kullanmadığımız için. Bu yüzden hibernate.current_session_context_class özelliğini set ediyoruz. Aksi takdirde "No CurrentSessionContext configured" şeklinde bir hata alırız. Bu dosyanın üst kısmındaki namespace 'ler de tabi ki önemlidir.

			
<!-- check out the hibernate-configuration-3.0.dtd and hibernate-configuration-4.0.xsd file for possible tags and structures -->
<p:hibernate-configuration xmlns:p="http://www.hibernate.org/xsd/orm/cfg" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.hibernate.org/xsd/orm/cfg hibernate-configuration-4.0.xsd ">
	<p:session-factory name="Session Factory">
		<!-- Of course you can create a Bean for session factoey and set the properties in java side -->
		<p:property name="hibernate.connection.url">jdbc:postgresql://localhost:5433/EJB</p:property>
		<p:property name="hibernate.connection.driver_class">org.postgresql.Driver</p:property>
		<p:property name="hibernate.connection.username">postgres</p:property>
		<!-- change the password -->
		<p:property name="hibernate.connection.password">yourpassword</p:property>
		<p:property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</p:property>
		<!-- create, update, validate, create-drop -->
		<p:property name="hibernate.hbm2ddl.auto">update</p:property>
		<p:property name="hibernate.show_sql">true</p:property>
		<!-- hibernate.current_session_context_class is either jta or thread -->
		<!-- we are not using any java transaction api manager, we are using hibernate session transactions, hence the thread -->
		<p:property name="hibernate.current_session_context_class">thread</p:property>
		<!-- i couldn't set the package name here so i had to indicate all the model classes manually -->
		<!-- <p:mapping package="com.numankaraaslan.jakartaejb.model" /> -->
		<!-- there are no autoscanning of entity clases here, this is not spring framework -->
		<p:mapping class="com.numankaraaslan.jakartaejb.model.Book" />
	</p:session-factory>
</p:hibernate-configuration>
			
		

BeanFactory sınıfı ve gerekli bean 'ler

Bu demo uygulamanın veritabanına veri yazıp okuması için gereken tek bean org.hibernate.SessionFactory bean 'i şu anda. Bu session factory ise tanımladığımız hibernate.cfg.xml dosyasından veri okuyacak. Bu sınıftan direkt olarak bean üretemedim. Spring framework 'de olduğu gibi metodun başına @Bean yazamadım çünkü :) Bu yüzden beanfactory sınıfımı singleton olarak tanımladım ve gerekli sınıflarda inject ederek kullandım. SessionFactory nesnesine bu şekilde ulaştım. Hibernate.cfg.xml dosyasını resources klasörüne koyacağız ve uygulama aşağıdaki kodlar vasıtasıyla buradan okuyacak. War dosyası içerisinde ise WEB-INF klasörünün hemen altına yerleşiyor. Uygulamanın build path ayarlarında resources klasörünü de dahil etmeyi unutmayınız eğer yoksa. Tabi ki hibernate.cfg.xml yerine kendi elinizle veritabanı ayarlarını bu sınıfta set edebilirsiniz. Veritabanı isminin "EJB" olduğuna dikkat ediniz ve bu veritabanını oluşturmayı unutmayınız.

			
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

import jakarta.annotation.PostConstruct;

@jakarta.ejb.Singleton
public class BeanFactory
{
	// Instead of using entitymanager, we are using session factory of hibernate
	private SessionFactory sessionFactory;

	// Initialize the session factory only once
	@PostConstruct
	public void initialize()
	{
		sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		// you can also hardcode properties like below
		// sessionFactory = new Configuration().setProperty("hibernate.connection.url", "jdbc:postgresql://localhost:5433/EJB");
	}

	// This is not a bean, i am calling manually
	public SessionFactory getSessionFactory()
	{
		return sessionFactory;
	}
}
			
		

Basit bir repository

Bu uygulama hibernate vasıtasıyla veritabanına ulaşacak ve connection için postresql driver 'ı kullanacak. Zaten gerekli ayarları hibernate.cfg.xml dosyasında mevcut. Repository sınıfımız CDI vasıtasıyla sesionfactory 'yi inject etmeli. Bu bean 'i beanfactory sınıfında üretmiştik. Buraya @jakarta.inject.Inject anotasyonu ile inject ediyoruz. Get ve Add metodlarımda da session.getTransaction().begin(); ve session.getTransaction().commit(); şeklinde transaction yönetimini manuel olarak yapıyoruz. Bu repository de başka sınıfta inject edilebilmesi için Singleton tanımlanıyor. Stateless 'da olabilirdi fakat bütün application context 'inde bir tane olmasını garantilemek için singleton öneriliyor bildiğim kadarıyla.

			
import java.util.List;

import org.hibernate.Session;
import org.hibernate.query.criteria.JpaCriteriaQuery;

import com.numankaraaslan.jakartaejb.config.BeanFactory;
import com.numankaraaslan.jakartaejb.model.Book;

@jakarta.ejb.Singleton
public class BookRepo
{
	private BeanFactory factory;
	
	// @Inject is actually new and improved @jakarta.ejb.EJB
	@jakarta.inject.Inject
	public void setFactory(BeanFactory factory)
	{
		this.factory = factory;
	}

	public List<Book> getBooks()
	{
		// Criteria API :@
		Session session = this.factory.getSessionFactory().getCurrentSession();
		session.getTransaction().begin();
		JpaCriteriaQuery<Book> query = session.getCriteriaBuilder().createQuery(Book.class);
		query.from(Book.class);
		List<Book> list = session.createQuery(query).getResultList();
		session.getTransaction().commit();
		return list;
	}

	public void save(Book book)
	{
		Session session = this.factory.getSessionFactory().getCurrentSession();
		session.getTransaction().begin();
		session.save(book);
		session.getTransaction().commit();
	}
}
			
		

Bu sistemde benim kullandığım model (yada entity nesnesi diyebiliriz) çok basit ve hibernate entity 'lerinin basic özelliklerini kullanıyor. Aşağıda kodları görebilirsiniz fakat postgresql tarafında "public" şemasını değil de kendi şemanızı kullanmak isterseniz öncelikle şema oluşturmayı unutmayınız. Paket isimlerine (jakarta.persistence) ve anotasyonlara da dikkat tabi. Bir de postgresql 'de şema ve tablo isimlerinde çift tırnak (") ile başlayıp bitirmeniz gerekebilir.

			
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@Entity
// this is a hibernate managed entity
// \"JakartaEE\" is the schema name and \"Book\" is the table name
// if you are using postgresql, you need the queries like create table "jakartaee"."book" with double quotes
// that's why i have to use \" on schema and table names
@Table(schema = "\"JakartaEE\"", name = "\"Book\"")
//Remember to create "JakartaEE" schema in posgtresql database
//CREATE SCHEMA JakartaEE AUTHORIZATION postgres; GRANT ALL ON SCHEMA JakartaEE TO postgres;
public class Book
{
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private int id;

	public Book(String name, int year, String author)
	{
		this.name = name;
		this.year = year;
		this.author = author;
	}

	@Column
	private String name;

	@Column
	private int year;

	@Column
	private String author;
}
			
		

BookServlet sınıfı

Uygulamanın bu kısmı biraz farklı. Günümüzde jersey gibi bir web servisi veya jakarta web servisleri veya spring framework altyapısı kullandığınızda kendi servlet implementasyonunuzu yazmak zorunda kalmıyorsunuz. O servletler gelen request ve response üzerinde gerekli işlemleri ve yönlendirmeleri yapabiliyor. Bu projede hazır bir servlet ve buna bağlı MVC sınıflarımız malesef yok. Bunun gibi JSP servlet projelerinde kendi servlet ve mvc yapımızı kurguluyoruz. Hatta başka bir örneğini de burada bulabilirsiniz. Yanlışım varsa düzeltiniz lütfen :)

Aşağıdaki servlet sınıfım jakarta.servlet.http.HttpServlet sınıfını extend ederek get ve post metodlarının sorumluluğunu üzerine alıyor, yani override ediyor. Kodlar karmaşık görünse de yaptığı işlem basit. BookRepo yani veritabanına erişen sınıfımız buraya @Inject ile inject ediliyor. Kitap ekleme sayfasında post işlemi, listeleme sayfasında ise get işlemi devreye giriyor. Get işleminde MVC yapısı gereği request.setAttribute ile JSP sayfasında listelenecek kitaplar listesini gönderiyoruz. Post işleminde ise ekrandan gelen kitap bilgisini form 'dan gelen input 'lardan alarak oluşturup veritabanına kaydediyoruz. Post işlemi için farklı bir yapının kullanılabileceğini düşünmekle birlikte (thymeleaf 'deki th:object gibi) malesef başka bir yöntem bilmiyorum. Zaten bu projenin bu kısmını dilediğiniz gibi değiştirmek ve geliştirmek hiç zor olmayacaktır.

Bu servlet içindeki get ve post isteklerinde request yönlendirme var. Benim demo projemde "/book" şeklinde bir klasör bulunduğu için bu sayfalara erişen url 'leri ilgili JSP sayfalarına yönlendiriyorum. Bunun için request.getRequestDispatcher("addbook.jsp").forward(request, response); şeklinde kodlar görüyorsunuz. Proje karmaşıklaştıkça bu yönlendirme ve href işlemleriniz de karmaşıklaşacaktır, şimdiden uyarayım. Bu servlet sınıfı da Stateless şeklinde tanımlı. Stateless, Stateful ve Singleton arasındaki farklar ile ilgili buraya bakabilirsiniz.

			
import java.io.IOException;

import com.numankaraaslan.jakartaejb.model.Book;
import com.numankaraaslan.jakartaejb.repo.BookRepo;

import jakarta.ejb.Stateless;
import jakarta.inject.Inject;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@Stateless
// The alternative approach without web.xml definition would be like below
// @WebServlet(urlPatterns = { "/book/addbook", "/book/books" })
public class BookServlet extends HttpServlet
{
	private static final long serialVersionUID = -4755981094229859819L;

	@Inject
	public BookRepo bookRepo;

	@Override
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		if (request.getRequestURI().endsWith("/addbook"))
		{
			// this is http://localhost:8080/JakartaEJB/book/addbook
			// i can directly redirect to "addbook.jsp", not "book/addbook.jsp" even though it is in the "book" folder (see webapp folder)
			// because i am already inside the /book mappings (see web.xml)
			request.getRequestDispatcher("addbook.jsp").forward(request, response);
		}
		else if (request.getRequestURI().endsWith("/books"))
		{
			// this is http://localhost:8080/JakartaEJB/book/books
			request.setAttribute("books", bookRepo.getBooks());
			// i can directly redirect to "list.jsp", not "book/list.jsp" even though it is in the "book" folder (see webapp folder)
			// because i am already inside the /book mappings (see web.xml)
			request.getRequestDispatcher("list.jsp").forward(request, response);
		}
		// here "request.setAttribute" is actually "modelandview.addobject" method in spring framework
	}

	@Override
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
	{
		if (request.getRequestURI().endsWith("/addbook"))
		{
			bookRepo.save(new Book(request.getParameter("name"), Integer.parseInt(request.getParameter("year")), request.getParameter("author")));
			response.sendRedirect("addbook.jsp");
		}
	}
}
			
		

Basit bir JSP sayfası

Sistemin MVC yapısını oturtmak adına servlet sınıfımızı yazdık. Sırada ekranları tasarlamak geliyor. Bu uygulama JSP servlet uygulaması olduğu için sunucuda çalışırken http://localhost:8080/JakartaEJB/book/books şeklinde linklerle erişilecektir. Books sayfası için bu istek geldiğinde yukarıdaki servlet ile list.jsp sayfasına yönlendirilecektir. Bu ekranda kullanacağımız veriyi yani modeli veya attribute 'ları servlet tarafından göndermiştik.

List.jsp sayfasının örneği ise aşağıda bulunuyor. Bu dosyada en üstteki iki satır epeyce önemli. Birinci satırdaki isELIgnored="false" language="java" kısmı ile sayfa dilinin java olduğunu belirttik. Ayrıca enteresan bir şekilde ekranda $ ile yazdığım ifadeleri jsp şeklinde değerlendirmemesi yüzünden ELIgnored yazmak zorunda kaldım. İkinci satırda da tabi ki JSP sayfası için kullanacağımız tag library 'yi ekledik. Sayfanın body kısmında ise <c:forEach items="${books}" var="book"> şeklinde servlet sınıfından gelen veriyi foreach mantığı ile ekrana eklemiş olduk. Book isimli bir değişken oluşturup bu değişkenin içindeki name verisine "book.name" ile eriştik. Bu da tabi ki arka planda reflection ile getName kodunun çalıştırılması ile mümkün oldu. Bu sayfa server tarafında render edilecek ve kullanıcıya düz html dosyası döndürülecek. Tabloda ise veritabanındaki kitap sayısı kadar satır oluşacak.

			
<%@ page isELIgnored="false" language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Spring JSP demo</title>
</head>
<body>
	<!-- going one level up in the folder structure ../index.jsp -->
	<a href="../index.jsp">home</a>
	<a href="books">books</a>
	<a href="addbook">add</a>
	<br />
	<table>
		<thead>
			<tr>
				<th>Name</th>
				<th>Year</th>
				<th>Author</th>
			</tr>
		</thead>
		<tbody>
			<c:forEach items="${books}" var="book">
				<tr>
					<td>${book.name}</td>
					<td>${book.year}</td>
					<td>${book.author}</td>
				</tr>
			</c:forEach>
		</tbody>
	</table>
</body>
</html>
			
		

Bu şekilde oluşturacağınız projenin yapısı aşağıdaki resimdekine benzer olacaktır.

Projeyi ayağa kaldırmak için Eclipse veya Intellij içerisinden direkt olarak run as -> run on server yapamayabilirsiniz. Çünkü bu proje için en yeni jakarta paketlerine entegre olmuş sunuculara ihtiyacınız var. Ben eclipse 'de yeni sunucu oluştururken tomcat 10 oluşturuyormuş gibi yapıp güncel TomEE 9 sunucusunu açabildim. Fakat aynı uygulama Jboss 'un güncel sürümlerinde veya Payara sunucusunda daha verimli çalışabilir. Bunların enterprise sürümleri de mevcut tabi ki. Uygulamayı ayağa kaldırdığınızda ise localhost:8080/JakartaEJB/index.jsp adresinden açabilirsiniz.

Minimal ve basit konfigürasyon ile uçuşa hazırız

Bu projede en güncel hali ile JavaEE yani JakartaEE kullanmış olduk. JakartaEE 'yi web servislerinde direkt olarak (jersey 'e gerek olmadan) jakarta.ws.rs şeklinde kullanabileceğinizi de not olarak belirteyim. EJB altyapısını kullandık yani bean 'lerimiz bir şekilde oluştu ve context 'e atıldı ve injectler yapıldı. Bu context spring 'deki gibi bir context değil direkt sunucunun yönettiği bir context. Ayrıca projeyi hibernate (JPA veya persistence da diyebiliriz) ile veritabanına da bağladık ve 6 sürümü ile jakarta paketini kullanmış olduk. Hibernate şu anda beta modunda olsa da elbet birgün stable sürüme geçecektir. Önyüz için ise JSP kullandık fakat dilerseniz JSF gibi daha üst düzey teknolojilere geçirmeniz mümkündür. Böylece JakartaEE, EJB, Hibernate ve JSP teknolojilerini kullanan güncel bir proje çatısı oluşturmuş olduk. Uygulama karmaşıklaştıkça bean sayınız artacak ve yapılarınız karmaşıklaşacaktır. Hangi tür bean 'leri kullanmalıyım sorusuna da göz atmanızı öneririm. Bir sonraki yazida görüşmek üzere :)