apache+tomcat+memcached

gdrocket

　　最近闲的蛋疼，顺便研究下apache+tomcat+memcache,顺便记录一下。

　　准备工作

• 
  apache
    http://httpd.apache.org/download.cgi（推荐大家选择2.2.2版本，否则还需要装apr,apr-util等）
  
• 
  
  tomcat 
      http://tomcat.apache.org/download-60.cgi
  
• 
  
  mod_jk
      http://archive.apache.org/dist/jakarta/tomcat-connectors/jk/source/jk-1.2.15/jakarta-tomcat-connectors-1.2.15-src.tar.gz
  
• 
  
  memcache
  http://memcached.org/
  
• 
  xmemcache
  
  http://code.google.com/p/xmemcached/downloads/detail?name=xmemcached-1.3.8-bin-with-dependencies.tar.gz&can=2&q=
  

　　
安装工作

       1.apache



# tar xzvf httpd-2.22.tar.gz


# cd httpd-2.22


# ./configure --prefix=/usr/local/apache --enable-so


# make


# make install


   
2.mod_jk



# tar xzvf jakarta-tomcat-connectors-1.2.15-src.tar.gz


# cd jakarta-tomcat-connectors-1.2.15-src/jk/native


# ./configure --with-apxs=/usr/test/apache/bin/apxs


# make


# cp ./apache-2.0/mod_jk.so /usr/test/apache/modules/

3.memcache



   这个有点多  详见http://yu-zhang430.iyunv.com/admin/blogs/1601197

 

 

配置工作

 # cd /usr/test/apache/conf/      在httpd.conf最后添加一句

                
Include  conf/jk.conf

 # touch jk.conf    在jk.conf写入以下配置

                LoadModule jk_module  modules/mod_jk.so

                JkWorkersFIle conf/workers.properties

                JkLogFile  conf/jk.log

                JkMount   /*.jsp    balancer//这里负责负载均衡

                JkMount /jkstatus.jsp  jkstatus//这里负责显示状态

#touch jk.log

#touch workers.properties  在workers.properties写入以下配置

               worker.list=balancer,jkstatus

              worker.tomcat1.host=localhost

              worker.tomcat1.port=8009

              worker.tomcat1.type=ajp13

              worker.tomcat1.lbfactor=1//设置负载的比重

              worker.tomcat2.host=localhost

              worker.tomcat2.port=8029

              worker.tomcat2.type=ajp13

　　              worker.tomcat2.lbfactor=1//设置负载的比重

             注：这里填的port不是tomcat的端口，曾经我填为8080和8081，测试一直不成功，这里的port是2个tomcat的AJP13的端口

             worker.balancer.type=lb

             worker.balancer.balance_workers=tomcat1,tomcat2

             worker.balancer.sticky_session=0这里设置session是否粘帖  0为不粘帖 

             worker.jkstatus.type=status

到此位置负载均衡完毕。下来我们用Memcached来完成Session同步。

1.修改web.xml添加filter

  <filter>
<filter-name>session</filter-name>
<filter-class>com.filter.SessionFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>session</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
 　　2.添加filter

package com.filter;
import java.io.IOException;
import java.util.UUID;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* Servlet Filter implementation class sessionFilter
*/
public class SessionFilter implements Filter {
private int timout=36000000;
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws IOException, ServletException {
HttpServletRequest request=(HttpServletRequest)servletRequest;
HttpServletResponse response=(HttpServletResponse)servletResponse;
Cookie[] cookies=request.getCookies();//获取cookie
String sessionId="";
if(cookies!=null&&cookies.length>0)
{
for(Cookie item:cookies)
{
if(item.getName().equals("sessionId"))
{
sessionId=item.getValue();//如果Cookie存在sessionId 重新计时
item.setMaxAge(timout);
}
}
}
if(cookies==null||sessionId.equals(""))
{
sessionId=UUID.randomUUID().toString();
Cookie cookie=new Cookie("sessionId", sessionId);
cookie.setMaxAge(timout);
response.addCookie(cookie);//如果Cookie不存在，创建cookie,生成sessionId添加到Cookie
}
//MyRequestWrapper装饰了httpservletrequest，我们重写一些request的方法
filterChain.doFilter(new MyRequestWrapper(sessionId,request), servletResponse);
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}

 　　3.MyRequestWarpper.java

package com.filter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpSession;
public class MyRequestWrapper extends HttpServletRequestWrapper {
private String sessionId;
public MyRequestWrapper(String sessionId,HttpServletRequest request) {
super(request);
this.sessionId=sessionId;
}
@Override
public HttpSession getSession() {
return new HttpSessionWrapper(sessionId, super.getSession());//重写getSession方法
}
@Override
public HttpSession getSession(boolean create) {
return  new HttpSessionWrapper(sessionId, super.getSession(create));
}
}

 　　3.HttpsessionWrapper.java

package com.filter;
import java.util.Enumeration;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionContext;
@SuppressWarnings({"deprecation","rawtypes","static-access"})
public class HttpSessionWrapper implements HttpSession {
private String sid = "";//sessionId
public static  Map map = null;//session
private int timeout=1800;
private HttpSession session;
public HttpSessionWrapper(String sid,HttpSession session) {
this.session = session;
this.sid = sid;
this.map = MyMemcachedCinent.getInstance().getSession(sid,timeout);
}
public Object getAttribute(String arg0) {
return this.map.get(arg0);
}
public Enumeration getAttributeNames() {
return (new Enumerator(this.map.keySet(), true));
}
public void invalidate() {
this.map.clear();
MyMemcachedCinent.getInstance().removeSession(this.sid);
}
public void removeAttribute(String arg0) {
this.map.remove(arg0);
MyMemcachedCinent.getInstance().saveSession(this.sid,timeout, this.map);
}
@SuppressWarnings("unchecked")
public void setAttribute(String arg0, Object arg1) {
this.map.put(arg0, arg1);
MyMemcachedCinent.getInstance().saveSession(this.sid,timeout, this.map);
}
public long getCreationTime() {
return session.getCreationTime();
}
public String getId() {
return session.getId();
}
public long getLastAccessedTime() {
return session.getLastAccessedTime();
}
public int getMaxInactiveInterval() {
return session.getMaxInactiveInterval();
}
public ServletContext getServletContext() {
return session.getServletContext();
}
public HttpSessionContext getSessionContext() {
return session.getSessionContext();
}
public Object getValue(String arg0) {
return session.getValue(arg0);
}
public String[] getValueNames() {
return session.getValueNames();
}

public boolean isNew() {
return session.isNew();
}
public void putValue(String arg0, Object arg1) {
session.putValue(arg0, arg1);
}

public void removeValue(String arg0) {
session.removeValue(arg0);
}

public void setMaxInactiveInterval(int arg0) {
session.setMaxInactiveInterval(arg0);
}
}

 

4.Enumerator.java

package com.filter;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.NoSuchElementException;
@SuppressWarnings({"rawtypes"})
public class Enumerator implements Enumeration {
private Iterator iterator = null;
public Enumerator(Collection collection) {
this(collection.iterator());
}
public Enumerator(Collection collection, boolean clone) {
this(collection.iterator(), clone);
}
public Enumerator(Iterator iterator) {
super();
this.iterator = iterator;
}
@SuppressWarnings("unchecked")
public Enumerator(Iterator iterator, boolean clone) {
super();
if (!clone) {
this.iterator = iterator;
} else {
List list = new ArrayList();
while (iterator.hasNext()) {
list.add(iterator.next());
}
this.iterator = list.iterator();
}
}
public Enumerator(Map map) {
this(map.values().iterator());
}
public Enumerator(Map map, boolean clone) {
this(map.values().iterator(), clone);
}
public boolean hasMoreElements() {
return (iterator.hasNext());
}
public Object nextElement() throws NoSuchElementException {
return (iterator.next());
}
}

　　5.MyMemcachedCinent

package com.filter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;
import net.rubyeye.xmemcached.MemcachedClient;
import net.rubyeye.xmemcached.MemcachedClientBuilder;
import net.rubyeye.xmemcached.XMemcachedClientBuilder;
import net.rubyeye.xmemcached.exception.MemcachedException;
import net.rubyeye.xmemcached.utils.AddrUtil;
@SuppressWarnings({"rawtypes"})
public class MyMemcachedCinent {
private static MyMemcachedCinent myMemcachedCinent;
private MemcachedClient client;
/**
* 初始类的时候启动memcached
*/
private  MyMemcachedCinent(){
MemcachedClientBuilder builder=new XMemcachedClientBuilder(AddrUtil.getAddresses("localhost:11211"));
try {
client=builder.build();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
*  MyMemcachedCinent单例
*  @author zhangyu  DateTime 2012-8-14 上午9:22:51
*  @return
*/
public static synchronized  MyMemcachedCinent getInstance()
{
if(myMemcachedCinent==null)
{
myMemcachedCinent= new MyMemcachedCinent();
}
return myMemcachedCinent;
}
/**
* 获取session
*  @author zhangyu  DateTime 2012-8-14 上午9:18:19
*  @param sid
*  @param timeout
*  @return
*/
public Map getSession(String sid,int timeout)
{
Map map=null;
try {
map = client.get(sid);
if(map==null)
{
map=new HashMap();
client.set(sid, timeout, map);
}
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
return map;
}
/**
*  添加Session或者更新Session
*  @author zhangyu  DateTime 2012-8-14 上午9:18:32
*  @param id
*  @param timeout
*  @param session
*/
public void saveSession(String id,int timeout, Map session) {
try {
client.set(id,timeout, session);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
}
/**
*  删除Session
*  @author zhangyu  DateTime 2012-8-14 上午9:19:00
*  @param id
*/
public void removeSession(String id) {
try {
client.delete(id);
} catch (TimeoutException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (MemcachedException e) {
e.printStackTrace();
}
}

}

　　 大功告成，session是通过Cookie和memcache保存的，如果要更保险点，可以判断下用户的cookie有木有北禁用，吧sessionId拼接到url里