嵌入式 jetty 启动应用

 一、jetty简介

    Jetty 目前的是一个比较被看好的 Servlet 引擎，它的架构比较简单，也是一个可扩展性和非常灵活的应用服务器，它有一个基本数据模型，这个数据模型就是 Handler，所有可以被扩展的组件都可以作为一个 Handler，添加到 Server 中，Jetty 就是帮你管理这些 Handler。关于jetty这里我再多说，没有研究过，本文说的是如何使用嵌入式jetty启动一个应用程序。

        Jetty 设计之初就是作为一个优秀的组件来设计的，这也就意味着 Jetty 可以非常容易的嵌入到 应用程序当中而不需要程序为了使用 Jetty 做修改。从某种程度上，你也可以把 Jetty 理解为一个 嵌入式的Web服务器。

Jetty 可以作为 嵌入式服务器使用，Jetty的运行速度较快，而且是轻量级的，可以在Java中可以从test case中控制其运行。从而可以使 自动化测试不再依赖外部环境，顺利实现自动化测试。

            Jetty有一个标语，“不要部署你的应用在Jetty上，部署Jetty在你的应用中”。这意味着可选择使用Jetty捆绑你的应用作为一个标准WAR进行部署。Jetty设计成一个软件组件，可以实例化并且使用在Java程序中，例如：如何POJO。但是另外一种方法，以嵌入式模式运行Jetty，这意味着把HTTP模块放入到你的应用中，而不是把你的应用放入到HTTP服务中。

 

       本文就给大家分享从最简单的Jetty服务实例到使用标准部署描述运行多个Web应用，只需要三步即可。

二、嵌入式jetty启动应用程序

    1、引用

     在web程序的pom文件中引入jetty的依赖   

   

<dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-server</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-webapp</artifactId>
            <version>${jetty.version}</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-jmx</artifactId>
            <version>${jetty.version}</version>
        </dependency>

   2、其次，编写一个工具类
    在web工程里添加嵌入式Jetty Server代码文件JettyServer.java内容如下：

public class JettyServerStart {
        private int           port;
        private String        context;
        private String        webappPath;
        private int           scanIntervalSeconds;
        private boolean       jmxEnabled;
        private Server        server;
        private WebAppContext webapp;
        public JettyServerStart(String webappPath, int port, String context) {
            this(webappPath, port, context, 0, false);
        }
        public JettyServerStart(String webappPath, int port, String context, int scanIntervalSeconds, boolean jmxEnabled) {
            this.webappPath = webappPath;
            this.port = port;
            this.context = context;
            this.scanIntervalSeconds = scanIntervalSeconds;
            this.jmxEnabled = jmxEnabled;
            validateConfig();
        }
        private void validateConfig() {
            if (port < 0 || port > 65536) {
                throw new IllegalArgumentException("Invalid port of web server: " + port);
            }
            if (context == null) {
                throw new IllegalStateException("Invalid context of web server: " + context);
            }
            if (webappPath == null) {
                throw new IllegalStateException("Invalid context of web server: " + webappPath);
            }
        }
        public void start() {
            if (server == null || server.isStopped()) {
                try {
                    doStart();
                } catch (Throwable e) {
                    e.printStackTrace();
                    System.err.println("System.exit() ......");
                    System.exit(1);
                }
            } else {
                throw new RuntimeException("Jetty Server already started.");
            }
        }
        private void doStart() throws Throwable {
            if (!portAvailable(port)) {
                throw new IllegalStateException("port: " + port + " already in use!");
            }
            System.setProperty("org.eclipse.jetty.util.URI.charset", "UTF-8");
            System.setProperty("org.eclipse.jetty.util.log.class", "org.eclipse.jetty.util.log.Slf4jLog");
            System.setProperty("org.eclipse.jetty.server.Request.maxFormContentSize", "20000000");
            server = new Server(port);
            server.setHandler(getHandler());
            if (jmxEnabled) {
                MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
                MBeanContainer mBeanContainer = new MBeanContainer(mBeanServer);
                server.addBean(mBeanContainer);
            }
            if (scanIntervalSeconds > 0) {
                startFileWatchScanner();
            }
            long ts = System.currentTimeMillis();
            server.start();
            ts = System.currentTimeMillis() - ts;
            System.err.println("Jetty Server started: " + String.format("%.2f sec", ts / 1000d));
            server.join();
        }
        protected Handler getHandler(){
            webapp = new WebAppContext(webappPath, context);
            return webapp;
        }
        private void startFileWatchScanner() throws Exception {
            List<File> scanList = new ArrayList<File>();
            scanList.add(new File(webappPath, "WEB-INF"));
            Scanner scanner = new Scanner();
            scanner.setReportExistingFilesOnStartup(false);
            scanner.setScanInterval(scanIntervalSeconds);
            scanner.setScanDirs(scanList);
            scanner.addListener(new Scanner.BulkListener() {
                @SuppressWarnings("rawtypes")
                public void filesChanged(List changes) {
                    try {
                        System.err.println("Loading changes ......");
                        webapp.stop();
                        webapp.start();
                        System.err.println("Loading complete.\n");
                    } catch (Exception e) {
                        System.err.println("Error reconfiguring/restarting webapp after change in watched files");
                        e.printStackTrace();
                    }
                }
            });
            System.err.println("Starting scanner at interval of " + scanIntervalSeconds + " seconds.");
            scanner.start();
        }
        private static boolean portAvailable(int port) {
            if (port <= 0) {
                throw new IllegalArgumentException("Invalid start port: " + port);
            }
            ServerSocket ss = null;
            DatagramSocket ds = null;
            try {
                ss = new ServerSocket(port);
                ss.setReuseAddress(true);
                ds = new DatagramSocket(port);
                ds.setReuseAddress(true);
                return true;
            } catch (IOException e) {
            } finally {
                if (ds != null) {
                    ds.close();
                }
                if (ss != null) try {
                    ss.close();
                } catch (IOException e) {
                }
            }
            return false;
        }
}

 3、最后，写一个启动程序的main方法，调用服务即可。

public class BajieJobStart {
    public static void main(String[] args) {
        String webapp = "src/main/webapp";
        new JettyServerStart(webapp, 9090, "/").start();
    }
}

就这样就搞定了。