Poster taggade med ‘ejb’

Sida 1/2:12

Här beskriver jag hur man snabbt och enkelt kan sätta upp en jee-applikation (ear, webapp- och ejb-modul) på några få minuter genom att använda sig av Maven-arketyper ifrån org.codehaus.mojo.archetypes och kommandot mvn archetype:generate. Vi tar också användning av eclipse m2e-plugin för att uppdatera beroenden mellan ear och web/ejb-modulerna.

För den som vill komma åt det som denna artikel producerar (finns lite mer godis också i form av enklare ejb och servlet-klasser) så finns den tillgänglig på github:
git clone http://github.com/cygni-stacktrace/j2ee-maven-5minutes

Generera jee-arketyper

Ställ dig i lämplig katalog för att påbörja skapandet av vårt projekt. Första gången vi kör mvn archetype:generate (ska köras sammanlagt 3 ggr) letar vi upp och anger siffran för codehause-arketypen ear-javaee6. För varje gång vi kör kommandot ser infon ungefär likadan ut.

EAR-input:

Define value for property ‘groupId’: : se.cygni.stacktrace.myearproject
Define value for property ‘artifactId’: : my-ear
Define value for property ‘version’:  1.0-SNAPSHOT: :
Define value for property ‘package’:  se.cygni.stacktrace.mywebexample: : ear

Andra gången anger vi siffran för arketypen webapp-javaee6. Input:

Define value for property ‘groupId’: : se.cygni.stacktrace.mywebexample
Define value for property ‘artifactId’: : my-web
Define value for property ‘version’: 1.0-SNAPSHOT: :
Define value for property ‘package’: se.cygni.stacktrace.mywebexample: : war

Tredje gången anger vi siffran för arketypen ejb-javaee6. Input:

Define value for property ‘groupId’: : se.cygni.stacktrace.myejbexample
Define value for property ‘artifactId’: : my-ejb
Define value for property ‘version’:  1.0-SNAPSHOT: :
Define value for property ‘package’:  se.cygni.stacktrace.myejbexample: : ejb

När vi är klara med det här kommer det finnas tre kataloger, my-ear, my-web och my-ejb med varsin pom.xml som har en hyfsat bra grunduppsättning av JEE-beroenden uppsatta från början.

Skapa en parent-pom

För att bland annat kunna bygga hela vår applikation i ett svep kopplar vi ihop dessa my-ear/my-web och my-ejb pom.xml till en och samma parent pom.xml. Skapa manuellt katalogen my-app på samma nivå som de andra katalogerna och en pom.xml fil med bland annat följande (hela my-app/pom.xml kan hittas här):

<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/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>se.cygni.stacktrace</groupId>
  <artifactId>my-app</artifactId>
  <packaging>pom</packaging>
  <version>1.0</version>
  <name>my-app</name>

  <modules>
  	<module>../my-ear</module>
  	<module>../my-web</module>
  	<module>../my-ejb</module>
  </modules>
...

I samband med att vi gör det här så tar vi också bort Version-taggen och sätter parent att vara my-app i pom.xml i my-web, my-ejb och my-ear. Hur alla pom.xml ser ut efter detta kan ses: här.

Nu kan vi nerifrån och upp genom ett kommando bygga web, ejb samt ear. Ställ dig bara i my-app och kör mvn package!

Modifiera ear att innehålla web och ejb-beroenden

Nu kör vi igång eclipse och tar hjälp av de verktyg som finns där för att sätta våra beroende mellan ear och ejb/web-modulerna. En förutsättning är att du har m2e-pluginen installerad i eclipse. Plocka den härifrån http://download.eclipse.org/technology/m2e/releases/ och när det är gjort så importerar du pom.xml i my-app-katalogen in i eclipse (File-> Import -> Maven -> Existing Maven Projects). Det kommer skapa 4 olika projekt i eclipse, my-app, my-ear, my-web och my-ejb.

Öppna upp my-ear/pom.xml och modifiera stycket:

 <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-ear-plugin</artifactId>
        <version>2.6</version>
        <configuration>
            <version>6</version>
            <defaultLibBundleDir>lib</defaultLibBundleDir>
        </configuration>
      </plugin>

till:

			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-ear-plugin</artifactId>
				<version>2.6</version>
				<configuration>
					<version>6</version>
					<defaultLibBundleDir>lib</defaultLibBundleDir>
					<modules>
						<ejbModule>
							<groupId>se.cygni.stacktrace.myejbexample</groupId>
							<artifactId>my-ejb</artifactId>
						</ejbModule>
						<webModule>
							<groupId>se.cygni.stacktrace.mywebexample</groupId>
							<artifactId>my-web</artifactId>
						</webModule>
					</modules>
				</configuration>
			</plugin>

Sen högerklickar du på my-ear-projektet i package explorer och väljer Maven -> Add dependency. I sökrutan anger du ”my-ejb”, då kommer ditt ejb-projekt att dyka upp och du väljer detta och klickar OK. Upprepa proceduren för my-web projektet. Din my-ear/pom.xml bör nu innehålla detta:

	<dependencies>
		<dependency>
			<groupId>se.cygni.stacktrace.mywebexample</groupId>
			<artifactId>my-web</artifactId>
			<version>1.0</version>
			<type>war</type>
		</dependency>
		<dependency>
			<groupId>se.cygni.stacktrace.myejbexample</groupId>
			<artifactId>my-ejb</artifactId>
			<version>1.0</version>
			<type>ejb</type>
		</dependency>
	</dependencies>

Efter det här kan man roa sig med att städa upp ytterligare i sina pom.xml filer genom att t.ex se till att maven-compiler-plugin bara finns i my-app/pom.xml med rätt version etc. Men i princip är din grundstruktur nu klar och du kan ställa dig i my-app och köra mvn package för att få en fin ear-fil som kan deployas på en jee6-kompatibel app-server.

Cygni är ett konsultbolag med ambitionen att vara Stockholms bästa arbetsgivare för skickliga systemutvecklare och systemarkitekter.​ Bland våra kunder finns Skandia, Aftonbladet, Cinnober, LensWay, Eniro, Metro, Com Hem och många andra företag som är ledande inom sin bransch.​ Cygni har således ingen branschinriktning, vi är specialister på agil systemutveckling och den kompetensen applicerar vi framgångsrikt i många olika branscher.​

Cygni består idag av 40 killar och tjejer i åldrarna 25-57.​ Vi upplever en mycket stark efterfrågan på våra tjänster och söker därför nu 5 stycken seniora javautvecklare/​systemarkitekter som trivs i konsultrollen.​

De flesta på Cygni är civilingenjörer men det är inget krav.​ Däremot vill vi att du älskar systemutveckling och har minst fyra års javaerfarenhet.​ Du ska helst ha jobbat med agil metodik och moderna ramverk som Spring och Hibernate.​ Som konsult hos oss arbetar du ofta tillsammans med Cygni-kollegor i utmanande och utvecklande uppdrag hos någon av våra kunder i centrala Stockholm.​ Ett intresse för exempelvis Scala, Groovy och Ruby är meriterande.

Läs gärna mer om oss på ​cygni.​se eller på vår teknikblogg Stacktrace!

Cygni är ett IT-konsultbolag med drygt 40 anställda som grundades 2006. Vi erbjuder expertis inom agil systemutveckling på moderna plattformar. Den genomsnittlige Cygnikonsulten är 35 år, civilingenjör i datateknik och har 12 års professionell erfarenhet av systemutveckling. Men den främsta styrkan sitter varken i erfarenhet eller utbildning. Den sitter i engagemanget att ständigt vilja utvecklas och bli en bättre konsult.

Med en stadig förankring i vår systemutvecklingsexpertis kan Cygni utföra konsultuppdrag i alla branscher i behov av avancerat systemstöd. Cygnis kunder finns idag främst inom finans, media, retail, telekom och spel.

Det som utmärker Cygni är vår selektiva rekryteringsprocess. Vi sätter aldrig kvantitativa tillväxtmål eftersom de skulle kunna komma i konflikt med våra kvalitetsmål. Sedan starten 2006 har Stockholms främsta konsulter inom agil systemutveckling handplockats, bland annat genom branschens tuffaste tekniktester. Det har gett oss en stark företagsgemenskap, obefintlig personalomsättning, nöjda kunder och ett mycket välfungerande internt kompetensutbyte.

Cygnis kontor är centralt beläget på Sturegatan 34 i Stockholm med utsikt över Humlegården. De flesta uppdrag som Cygni utför är på plats hos våra kunder i Stockholmsområdet men kontoret fungerar som en naturlig samlingsplats för konsultmöten, afterwork och andra aktiviteter.

Karta till Cygnis kontor
Cygni
Sturegatan 34
114 36 Stockholm
Tel: 08 459 93 30
E-post: info@cygni.se 

Cygni sponsrar BRIS i deras arbete att stödja utsatta barn. Sedan 2012 är Cygni ett av BRIS guldföretag.

Följ oss via LinkedIn, Twitter eller Facebook

Cygni på LinkedIn


Rena kommandoradsapplikationer i Java kanske inte hör till vanligheterna nu mera, men det finns tillämpningar. Jag håller för tillfället på med ett sådant program. Det är en slags (av prestandaskäl) multitrådad övervakningsapplikation. Varje tråd ligger och pollar en databas efter något att arbeta med i ganska täta (några sekunders) intervall. När tråden hittar något att processa, så pratar den bl.a. JDBC med en stordatorapplikation.

Denna typ av beteende skulle vara ganska svårt att få till inom ramen för en appserver. Att starta trådar är ju inte aktuellt. Att använda Quartz eller ha ett cron-jobb som anropar en EJB via wget eller liknande skulle vara möjligt men verkar lite krystat, speciellt då den pollar så pass ofta.

En vanlig Java-applikation fick det bli, således. Vad bör man tänka på när man skriver en sådan applikation? Den är ju nästan som en slags server, som skall köra kontinuerligt. Den får inte gå ner så lättvindigt och den kommer sannolikt köra på en Linuxburk i ett serverrum någonstans utan något egentligt användargränssnitt. Här kommer således några tips för den standalone-inriktade.
Läs mer >>

Detta inlägg ingår i serien Spring från början och kommer att behandla det transaktionsstöd som finns i springmodulen spring-tx.

Transaktioner är ett sätt att hålla ihop en eller flera operationer. Typiskt gäller principen ”allt eller inget” vilket betyder att alla operationer som ingår i en transaktion ska exekveras utan fel för att transaktionen ska gälla. Det vanligaste fallet är databastransaktioner där exempelvis flera skrivningar måste exekveras utan fel innan en så kallad commit genomförs. Ett exempel på detta är det klassiska bankkontoexemplet med överflyttning av pengar från ett konto till ett annat. En överflyttning sker genom att ett uttag först sker från ett konto och sedan insättning på ett annat konto. Bägge operationerna måste lyckas, annars ska transaktionen inte gälla det vill säga att man ”rullar tillbaka” transaktionen via en så kallad rollback.

Spring erbjuder på ett enhetligt sätt stöd för att kunna hantera transaktioner av olika slag som till exempel JTA, JDBC, Hibernate, JPA och JDO. Transaktionsstödet kan användas på två sätt, deklarativt eller programmatiskt. Det deklarativa sättet är det absolut vanligaste och innebär att metadata kring transaktionslogik inte ligger inbäddad i den faktiska javakoden utan enbart finns deklarerad ”utanför” javakoden via metadata. Metadata kan antingen bestå av externa XML-filer eller annotationer och påverkar alltså inte javakoden, den är så att säga non-intrusive.

Läs mer >>

Denna artikel ingår i serien Spring från början och kommer behandla det springstöd som finns för OSGi. Denna artikel är inte direkt en ”tutorial” utan ger främst en orientering till OSGi och Spring Dynamic Modules och gör ett försök till att peka på lämpliga användningsområden.

Vad är OSGi och vad är det bra för?

Förkortningen , vilket i vart fall inte hjälper mig att förstå vad OSGi egentligen är.
OSGi står tydligen för Open Service Gateway Initiative, men det har inte hjälpt någon att förstå vad det OSGi egentligen är får något. OSGi-standarden är helt kort en standard för modularisering av javaapplikationer.

OSGi används i allt från inbäddade system, mobiltelefoner till en flerskiktade webbapplikationer. Standarden har funnits i flera år och har tidigare främst används i inbäddade system. Det är först på senare år som OSGi har blivit aktuellt att använda i serverapplikationer. Den kanske mest kända applikationen som bygger på OSGi är den populära utvecklingsmiljön Eclipse, som använder OSGi i sitt plug-in system.

Mer konkret så specificerar standarden tre områden; paketering av moduler, tjänsteregister och modulers livscykler. Läs mer >>

EJB 3.0 är den nu gällande versionen av Java Enterprise Beans(EJB) arkitekturen som ingår i Java EE 5. Syftet med EJB 3.0 är att förbättra arkitekturen för EJB och minska komplexiteten för utvecklaren av EJB applikationer. Detta innebär tex följande förbättringar:

  • Annoteringar, det finns ett gäng med annoteringar som man kan använda sig utav för att förenkla arbetet. Dessa annoteringar minskar antalet klasser och interface som man måste skapa och man behöver inte skapa någon deployment descriptor (om man inte vill).
  • Defaulta värden, man skall slippa specifiera en massa vanliga förväntade beteenden och krav från EJB-containern.
  • Inkapsling av beroenden och JNDI åtkomst via annoteringar och dependency injection (DI)
    Businessinterfacet för en sessionsböna kan vara ett vanligt Java-interface, det behöver inte vara av typen EJBObject, EJBLocalObject eller javax.rmi.Remote
  • Home-interfacet behövs inte längre för sessionsbönor.
  • Minskning av krav av användning av checked exceptions
  • En interceptor funktionalitet finns för sessions- och message-driven-bönor.
  • Entitetsbönor har fått en helt egen specifikation, Java Persistence API (JPA), är numera vanliga POJO’s.

Det finns ett par olika typer av EJB:er, sessionsbönor och message-driven-bönor. Sessionsbönorna kommer i två olika smaker, Stateless och Stateful. Entitetsbönorna har ju som sagt ersatts med JPA entiteter. Jag tänkte gå igenom dessa med små korta exempel. Läs mer >>

Cygni har idag tecknat avtal om att leverera avancerade systemutvecklingstjänster till en av Sveriges ledande leverantörer av bredband och kommunikationslösningar.

Den nya kunden är Cygnis första telekomkund vilket är ytterligare ett bevis för att Cygnis expertis inom open source och moderna javaarkitekturer är eftertraktad i de flesta branscher. I detta uppdrag är arkitekturen baserad på EJB3 och Suns applikationsserver Glassfish.

Detta inlägg ingår i serien Spring från början och kommer att behandla Springs stöd för Hibernate. Vi kommer inte att gå närmare in på vad Hibernate är och gör utan koncentrera oss på vad Spring kan hjälpa oss med och hur man kan jobba med HibernateTemplate och andra centrala klasser i modulen spring-orm. ORM står för Object Relational Mapping och modulen spring-orm innehåller dessutom stöd för JPA, TopLink och iBATIS.
Läs mer >>

Denna artikel behandlar hur man kan kombinera traditionell J2EE-utveckling (applikationsserver med Stateless Session Beans och liknande) med Spring Framework och samtidigt erhålla en kort Code-Build-Test-cykel, hur man får det bästa av två världar. Läs mer >>

Sida 1/2:12