如何用Web服务器搭建自己的Jetty服务器

标签：

在项目中,往往要手动设置一个Jetty服务器进行各种参数处理,比如之前在游戏公司,用的就是游戏服内部搭建Jetty服务器,然后方便外部访问.

主要用到这几块.

本身就是Web应用了,还用Jetty干嘛,当然,我这只是做个示例,以后做app或者平台级应用都可以用Jetty搭建外部访问Servlet.

首先,我们设置WebServer,并且设置在监听器里,使得WEB服务器启动的时候可以加载Jetty服务器,

这里是WebServer代码:

[java] view plain copy

 

 

1. package com.dc.web;  
2.   
3. /** 
4.  * Date: 2014-2-17 
5.  * 
6.  * Copyright (C) 2013-2015 7Road. All rights reserved. 
7.  */  
8.   
9.   
10. import java.util.HashMap;  
11. import java.util.List;  
12. import java.util.Map;  
13.   
14. import javax.servlet.Servlet;  
15.   
16. import org.dom4j.DocumentException;  
17. import org.eclipse.jetty.server.Server;  
18. import org.eclipse.jetty.server.handler.HandlerList;  
19. import org.eclipse.jetty.server.handler.ResourceHandler;  
20. import org.eclipse.jetty.servlet.ServletContextHandler;  
21. import org.eclipse.jetty.servlet.ServletHolder;  
22. import org.slf4j.Logger;  
23. import org.slf4j.LoggerFactory;  
24.   
25. import com.road.pitaya.web.WebHandleAnnotation;  
26. import com.road.util.ClassUtil;  
27.   
28. /** 
29.  *  
30.  * @author Tower 
31.  */  
32. public class WebServer  
33. {  
34.     private static final Logger LOGGER = LoggerFactory  
35.             .getLogger(WebServer.class);  
36.   
37.     /** 
38.      * jetty自带的server 
39.      */  
40.     private Server server;  
41.   
42.     /** 
43.      * 触发的处理器 
44.      */  
45.     private ServletContextHandler context;  
46.   
47.     /** 
48.      * 处理器列表 
49.      */  
50.     private HandlerList handlerList = new HandlerList();  
51.   
52.     /** 
53.      * 触发的资源处理器 
54.      */  
55.     private ResourceHandler resourceHandler;  
56.       
57.     /** 
58.      * 单例加载器 
59.      */  
60.     private static class LazyHolder  
61.     {  
62.         private static final WebServer INSTANCE = new WebServer();  
63.     }  
64.   
65.     /** 
66.      * 获取实例 
67.      *  
68.      * @return 
69.      */  
70.     public static WebServer getInstance()  
71.     {  
72.         return LazyHolder.INSTANCE;  
73.     }  
74.       
75.     public boolean start()  
76.     {  
77.         LOGGER.info("WebServer is starting...");  
78.         server = new Server(7039);  
79.   
80.         try  
81.         {  
82.             context = new ServletContextHandler(ServletContextHandler.SESSIONS);  
83.             context.setContextPath("/");  
84.             context.setResourceBase("");  
85.   
86.             resourceHandler = new ResourceHandler();  
87.             resourceHandler.setResourceBase("/webResource/");  
88.   
89.             handlerList.addHandler(context);  
90.             handlerList.addHandler(resourceHandler);  
91.   
92.             server.setHandler(handlerList);  
93.   
94.             loadServletByWebServerConfig();  
95.   
96.             server.start();  
97.         }  
98.         catch (DocumentException e)  
99.         {  
100.             LOGGER.error("load Xml Failed");  
101.             e.printStackTrace();  
102.             return false;  
103.         }  
104.         catch (Exception e)  
105.         {  
106.             e.printStackTrace();  
107.             return false;  
108.         }  
109.         LOGGER.info("WebServer has started successfully");  
110.         return true;  
111.     }  
112.       
113.     /** 
114.      * 加载Servlet的不同接口 
115.      *  
116.      * @return 
117.      */  
118.     public Map<String, Class<?>> resetMapHandle()  
119.     {  
120.         Map<String, Class<?>> HandleMap = new HashMap<String, Class<?>>();  
121.   
122.         // 从相应的包加载Servlet的不同接口  
123.         List<Class<?>> activityClass = ClassUtil  
124.                 .getClasses("com.dc.servlet");  
125.   
126.         for (Class<?> class1 : activityClass)  
127.         {  
128.             WebHandleAnnotation annotation = class1  
129.                     .getAnnotation(WebHandleAnnotation.class);  
130.             if (annotation != null)  
131.             {  
132.                 HandleMap.put(annotation.cmdName(), class1);  
133.             }  
134.         }  
135.   
136.         return HandleMap;  
137.     }  
138.   
139.     /** 
140.      * 使用WebServerConfig加载Servlet类 
141.      *  
142.      * @return 
143.      * @throws DocumentException 
144.      */  
145.     private boolean loadServletByWebServerConfig()  
146.     {  
147.   
148.         Map<String, Class<?>> HandleMap = resetMapHandle();  
149.         for (Map.Entry<String, Class<?>> one : HandleMap.entrySet())  
150.         {  
151.             try  
152.             {  
153.                 String path = one.getKey();  
154.                 Servlet servlet = (Servlet) one.getValue().newInstance();  
155.                 context.addServlet(new ServletHolder(servlet), path);  
156.             }  
157.             catch (InstantiationException e)  
158.             {  
159.                 e.printStackTrace();  
160.                 continue;  
161.             }  
162.             catch (IllegalAccessException e)  
163.             {  
164.                 e.printStackTrace();  
165.                 continue;  
166.             }  
167.         }  
168.         return true;  
169.   
170.     }  
171.       
172.     public boolean close()  
173.     {  
174.         LOGGER.info("WebServer is closing...");  
175.         try  
176.         {  
177.             server.stop();  
178.         }  
179.         catch (Exception e)  
180.         {  
181.             e.printStackTrace();  
182.         }  
183.         LOGGER.info("WebServer has closed successfully");  
184.         return true;  
185.     }  
186.   
187. }  

设置参数,启动,初始化,这些内容.

[java] view plain copy

 

 

1. package com.dc.servlet;  
2.   
3. import java.io.IOException;  
4. import java.io.PrintWriter;  
5. import java.util.Date;  
6.   
7. import javax.servlet.ServletException;  
8. import javax.servlet.http.HttpServlet;  
9. import javax.servlet.http.HttpServletRequest;  
10. import javax.servlet.http.HttpServletResponse;  
11.   
12. import org.slf4j.Logger;  
13. import org.slf4j.LoggerFactory;  
14.   
15. import com.google.gson.Gson;  
16. import com.road.entity.info.UserInfo;  
17. import com.road.pitaya.component.LanguageComponent;  
18. import com.road.pitaya.database.DataOption;  
19.   
20. /** 
21.  * 中控接口继承用 
22.  *  
23.  * @author Tower 
24.  */  
25. public abstract class AbstractServlet extends HttpServlet  
26. {  
27.     private static final long serialVersionUID = 2421477169746085074L;  
28.     @SuppressWarnings("unused")  
29.     private Logger LOGGER = LoggerFactory.getLogger(AbstractServlet.class);  
30.     /** 
31.      * 用于处理实体类的Gson实例 
32.      */  
33.     protected final Gson gson = new Gson();  
34.     /** 请求客户端的IP */  
35.     protected String requestIP = null;  
36.     @Override  
37.     public void doGet(HttpServletRequest request, HttpServletResponse response)  
38.             throws ServletException, IOException  
39.     {  
40.         doPost(request, response);  
41.     }  
42.   
43.     @Override  
44.     protected void doPost(HttpServletRequest request,  
45.             HttpServletResponse response) throws ServletException, IOException  
46.     {  
47.         String result = null;  
48.         try  
49.         {  
50.             requestIP = com.dc.util.ServletUtil.getRequestIP(request);  
51.             result = execute(request, response);  
52.         }  
53.         catch (Exception e)  
54.         {  
55.             e.printStackTrace();  
56.         }  
57.         response.setCharacterEncoding("UTF-8");  
58.   
59.         response.setContentType("text/html");  
60.         response.setStatus(HttpServletResponse.SC_OK);  
61.   
62.         PrintWriter out = response.getWriter();  
63.         out.print(result);  
64.         out.flush();  
65.         out.close();  
66.     }  
67.   
68.     public abstract String execute(HttpServletRequest request,  
69.             HttpServletResponse response) throws ServletException, IOException;  
70.       
71.     /** 
72.      * 创建一个新的账号 
73.      * @return 
74.      */  
75.     protected UserInfo newUserInfo(String site, String iuid, String pssd, Date createTime)  
76.     {  
77.         UserInfo userInfo = new UserInfo();  
78.         userInfo.setOp(DataOption.INSERT);  
79.         userInfo.setSite(site);//所属平台  
80.         userInfo.setIuid(iuid);//账号  
81.         userInfo.setPssd(pssd);//密码  
82.         userInfo.setCreateTime(createTime);//创建时间  
83.         userInfo.setServerId(0);// 账号所在服编号（这里暂不分服）  
84.         return userInfo;  
85.     }  
86.       
87.     protected String formatTime(long millis)  
88.     {  
89.         int m = (int)(millis/1000);  
90.         int ss = m%60;  
91.         int mm = m/60%60;  
92.         int hh = m/3600%24;  
93.         int dd = m/86400;  
94.         String time = "";  
95.         if(dd > 0)  
96.             time = LanguageComponent.getResource("Login.ServerStatusdd", dd, hh, mm, ss);  
97.         else if(hh > 0)  
98.             time = LanguageComponent.getResource("Login.ServerStatushh", hh, mm, ss);  
99.         else if(mm > 0)  
100.             time = LanguageComponent.getResource("Login.ServerStatusmm", mm, ss);  
101.         else if(ss > 0)  
102.             time = LanguageComponent.getResource("Login.ServerStatusss", ss);  
103.         return time;  
104.     }  
105.   
106.       
107. }  

中控接口继承用

然后就是我们测试的Servlet

[java] view plain copy

 

 

1. package com.dc.servlet;  
2.   
3. import java.io.IOException;  
4.   
5. import javax.servlet.ServletException;  
6. import javax.servlet.http.HttpServletRequest;  
7. import javax.servlet.http.HttpServletResponse;  
8.   
9. import com.road.pitaya.web.WebHandleAnnotation;  
10.   
11. /** 
12.  * 测试接口 
13.  * @author Tower 
14.  * 
15.  */  
16. @WebHandleAnnotation(cmdName = "/doSomething", description = "测试接口.")  
17. public class DoSomethingServlet extends AbstractServlet{  
18.   
19.     /** 
20.      *  
21.      */  
22.     private static final long serialVersionUID = -7574673387670968292L;  
23.   
24.     @Override  
25.     public String execute(HttpServletRequest request,  
26.             HttpServletResponse response) throws ServletException, IOException {  
27.         System.out.println(111111111);  
28.         return null;  
29.     }  
30.   
31. }  

对于webResources可以看到有个配置文件:

名字叫:crossdomain.xml

从名字可以看出来,这个是跨域策略,方便跨域访问.

[html] view plain copy

 

 

1. <?xml version="1.0"?>  
2. <cross-domain-policy>  
3.   <allow-access-from domain="*" />  
4. </cross-domain-policy>  

内容就这些,只是作为实现.

准备就做完了,我们启动tomcat,

Jetty正常启动.

我们之前设置的端口是7039

我们在doSomething设置一个断点,然后我们访问localhost:7039/doSomething 可以看到,断点进去,

控制台输出,于是,我们一个简单的Jetty服务器就搭建完成了,以后可以根据这个Jetty服务器进行其他各项操作.

如何用Web服务器搭建自己的Jetty服务器

标签：

原文地址：http://www.cnblogs.com/miercler/p/5396386.html