用 embedded glassfish 做 Java EE 实验

最新推荐文章于 2025-09-07 11:16:07 发布

原创最新推荐文章于 2025-09-07 11:16:07 发布 · 1.5k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#glassfish #java #ejb #exception #command #thread

JavaEE 同时被 3 个专栏收录

7 篇文章

订阅专栏

Glassfish

2 篇文章

订阅专栏

Embedded Glassfish

1 篇文章

订阅专栏

本文介绍了如何在Java EE实验中利用embedded glassfish作为容器，通过修改pom.xml配置，创建EmbededGlassfishManager启动和关闭Glassfish。虽然尝试了@EJB注解进行依赖注入但未成功，对于embedded glassfish中是否支持@EJB的使用留待进一步研究。此外，文章还展示了使用command模式的CommandExecution接口，以及包含main函数的App.java执行代码。

首先在maven的pom文件中引入embedded glassfish

pom.xml

<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>

	<groupId>cn.edu.zsu</groupId>
	<artifactId>quickstart</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>quickstart</name>
	<url>http://maven.apache.org</url>

	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		<dependency>
			<groupId>commons-pool</groupId>
			<artifactId>commons-pool</artifactId>
			<version>1.5.6</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish.extras</groupId>
			<artifactId>glassfish-embedded-all</artifactId>
			<version>3.1.1</version>
		</dependency>
		<dependency>
			<groupId>org.glassfish</groupId>
			<artifactId>javax.ejb</artifactId>
			<version>3.1.1</version>
			<scope>provided</scope>
		</dependency>
	</dependencies>
	<build>
		<finalName>quickstart</finalName>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>2.3.2</version>
				<configuration>
					<encoding>${project.build.sourceEncoding}</encoding>
					<source>${project.build.sourceVersion}</source>
					<target>${project.build.targetVersion}</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-resources-plugin</artifactId>
				<version>2.5</version>
				<configuration>
					<encoding>${project.build.resourcesEncoding}</encoding>
				</configuration>
			</plugin>

		</plugins>
	</build>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.build.resourcesEncoding>UTF-8</project.build.resourcesEncoding>
		<project.build.sourceVersion>1.7</project.build.sourceVersion>
		<project.build.targetVersion>1.7</project.build.targetVersion>
	</properties>
	<repositories>
		<repository>
			<id>EclipseLink Repo</id>
			<!-- note that ampersands in this URL are escaped because this is in an 
				xml file - un-escape them to use in browser -->
			<url>http://www.eclipse.org/downloads/download.php?r=1&nf=1&file=/rt/eclipselink/maven.repo</url>
		</repository>
	</repositories>

</project>

动手写一个启动和关闭Glassfish的类，代码比较浅显易懂，不予赘述。
EmbededGlassfishManager.java

package cn.edu.zsu.quickstart.ejb;

import org.glassfish.embeddable.GlassFish;
import org.glassfish.embeddable.GlassFishException;
import org.glassfish.embeddable.GlassFishProperties;
import org.glassfish.embeddable.GlassFishRuntime;

import cn.edu.zsu.quickstart.CommandExecution;

import com.sun.istack.logging.Logger;

/**
 * 演示启动和关闭一个embedded glassfish，设置了端口。
 * 
 * @author Justin
 * 
 */
public class EmbededGlassfishManager implements CommandExecution {
	/**
	 * 
	 */
	private Logger logger = Logger.getLogger(getClass());

	@Override
	public void close() throws Exception {

	}

	@Override
	public void execute() {
		GlassFishProperties gfProps = new GlassFishProperties();
		gfProps.setPort("http-listener", 8080);

		GlassFish glassfish = null;
		try {
			glassfish = GlassFishRuntime.bootstrap().newGlassFish(gfProps);
			logger.info(glassfish.getStatus().name());

			glassfish.start();

			logger.info(glassfish.getStatus().name());
			logger.info(glassfish.getDeployer().getClass().getName());

		} catch (GlassFishException e) {
			logger.severe(e.getLocalizedMessage(), e);
		} finally {
			/** Stop GlassFish */
			try {
				glassfish.stop();
				logger.info(glassfish.getStatus().name());

			} catch (GlassFishException e) {
				logger.severe(e.getLocalizedMessage(), e);
			}
		}

	}

}

下面这个演示是关键，有了embedded glassfish，我就可以在容器里测试一个ejb了。不过——我试了一下用@EJB来给LifecycleEJB lifecycleEJB进行依赖注入，没能成功。能否在embedded glassfish中使用@EJB仍待探寻。

EmbededEJBContainer .java

package cn.edu.zsu.quickstart.ejb;

import java.util.logging.Level;

import javax.ejb.embeddable.EJBContainer;
import javax.naming.Context;
import javax.naming.NamingException;

import cn.edu.zsu.quickstart.CommandExecution;

import com.sun.istack.logging.Logger;

/**
 * 用于演示怎样实验、测试一个ejb及其他javaee物件。
 * 
 * @author Justin
 * 
 */
public class EmbededEJBContainer implements CommandExecution {

	private LifecycleEJB lifecycleEJB;

	@Override
	public void close() throws Exception {
	}

	@Override
	public void execute() {
		Logger logger = Logger.getLogger(this.getClass());
		logger.setLevel(Level.INFO);

		/**
		 * 获取 ejbContainer
		 */
		EJBContainer ejbContainer = EJBContainer.createEJBContainer();

		try {
			/**
			 * 通过jndi找到LifecycleEJB并调用
			 */
			Context context = ejbContainer.getContext();
			lifecycleEJB = (LifecycleEJB) context
					.lookup("java:global/classes/LifecycleEJB");
			if (lifecycleEJB != null) {
				logger.info(lifecycleEJB.hello("say咗句hello"));
			} else {
				logger.severe("找不到ejb");
			}
		} catch (NamingException e) {
			logger.info("JNDI 错误", e);
		} finally {
			ejbContainer.close();
			logger.exiting("ejbContainer 关闭完成");
		}

	}
}

LifecycleEJB 这个是LifecycleEJB的代码

LifecycleEJB.java

package cn.edu.zsu.quickstart.ejb;

import java.util.logging.Logger;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

import cn.edu.zsu.quickstart.interceptor.ObserveInterceptor;

/**
 * 用于观察一个ejb的lifecycle
 * 
 * @author Justin
 * 
 */
@Stateless
public class LifecycleEJB {

	private Logger logger;

	public LifecycleEJB() {
		logger = Logger.getGlobal();
		logger.info("lifecycleEJB的构造函数");
	}

	@PreDestroy
	public void preDestory() {
		logger.info("lifecycleEJB的preDestory");
	}

	@PostConstruct
	public void postConstruct() {
		logger.info("lifecycleEJB的postConstruct");
	}

	/**
	 * 在此处应用interceptor
	 * 
	 * @param message
	 * @return
	 */
	@Interceptors({ ObserveInterceptor.class })
	public String hello(String message) {
		logger.info(String.format("输入的字符串是：%s", message));
		return "Echo: " + message;
	}
}

附加上CommandExecution接口的代码，使用command模式主要是因为我不想在做实验的工程里面建立太多的main函数，不想开太多工程，同时又希望把所有做过的代码保存下来，因此采用了command 模式。

这个接口继承了AutoCloseable接口。这是一个jdk7引入的新接口，用途请参考jdk文档。

CommandExecution.java

package cn.edu.zsu.quickstart;

/**
 * Applying Command Patterns
 * 
 * @author Justin
 * 
 */
public interface CommandExecution extends AutoCloseable {
	public void execute();
}

带main函数的执行代码

App.java

package cn.edu.zsu.quickstart;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import cn.edu.zsu.quickstart.ejb.EmbededEJBContainer;

/**
 * 
 * @author Justin
 * 
 */
public class App {

	/**
	 * 
	 * @param args
	 */
	public static void main(String[] args) {

		final Class<EmbededEJBContainer> claz = EmbededEJBContainer.class;
		/**
		 * 获取一个command
		 */
		try (CommandExecution exec = CommandExecutionFactory
				.createInstance(claz)) {
			Thread thread = new Thread(new Runnable() {
				@Override
				public void run() {
					exec.execute();
				}
			});

			ExecutorService service = Executors.newSingleThreadExecutor();
			service.execute(thread);
		} catch (InstantiationException | IllegalAccessException
				| ClassNotFoundException e) {
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}