【mongo】

最新推荐文章于 2024-07-11 17:14:41 发布

l青青子衿l

最新推荐文章于 2024-07-11 17:14:41 发布

阅读量204

点赞数

分类专栏： Demo

本文链接：https://blog.csdn.net/tiankongdefengling/article/details/79928011

版权

Demo 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

配置文件constants.properties

lucene_path=/root/www/lucene-index1

#static_host=http://114.215.109.13:9000
#static_host=http://jemer:80
#static_host=http://182.92.109.146:8001
static_host=http://192.168.0.2:8090
img_path=/files/img/
file_path=/files/upfile/
music_path=/upload/

article_image_max_height=200
article_image_max_width=200

doctor_head_max_height=200 
doctor_head_max_width=200

customer_head_max_height=200
customer_head_max_width=200

article_focus_image_max_height=200
article_focus_image_max_width=200

diet_calorie_image_max_height=50
diet_calorie_image_max_width=50

luntan_image_max_height=1200
luntan_image_max_width=1200
# 5M
img_max_size=5242880
img_ext=.gif,.png,.jpg,.jpeg,.bmp
# 500M
media_max_size=524288000
media_ext=.flv,.swf,.mkv,.avi,.rm,.rmvb,.mpeg,.mpg,.ogg,.ogv,.mov,.wmv,.mp4,.mp3,.webm,.wav,3gp
# 5M
file_max_size=5242880
file_ext=.rar,.doc,.docx,.xls,.xlsx,.ppt,.pptx,.zip,.pdf,.txt,.gif,.png,.jpg,.jpeg,.bmp

Constants.java获取constants.properties中的数据，拼接图片访问路径

package com.huidaifu.common.prop;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

import org.apache.log4j.Logger;


public class Constants {

	private static Logger logger=Logger.getLogger(Constants.class);
	public static  String ARTICLE_IMAGE_MAX_HEIGHT="article_image_max_height";
	public static  String ARTICLE_IMAGE_MAX_WIDTH="article_image_max_width";
	public static  String DOCTOR_HEAD_MAX_HEIGHT="doctor_head_max_height";
	public static  String DOCTOR_HEAD_MAX_WIDTH="doctor_head_max_width";
	public static  String CUSTOMER_HEAD_MAX_HEIGHT="customer_head_max_height";
	public static  String CUSTOMER_HEAD_MAX_WIDTH="customer_head_max_width";
	public static String ARTICLE_FOCUS_IMAGE_MAX_HEIGHT="article_focus_image_max_height";
	public static String ARTICLE_FOCUS_IMAGE_MAX_WIDTH="article_focus_image_max_width";
	public static  String IMG_PATH="img_path";
	public static  String FILE_PATH="file_path";
	public static  String MUSIC_PATH="music_path";
	public static  String LUCENE_PATH="lucene_path";
	public static  String STATIC_HOST="static_host";
	public static  String IMG_MAX_SIZE="img_max_size";
	public static  String IMG_EXT="img_ext";
	public static  String MEDIA_MAX_SIZE="media_max_size";
	public static  String MEDIA_EXT="media_ext";
	public static  String FILE_MAX_SIZE="file_max_size";
	public static  String FILE_EXT="file_ext";
	private static String fullFilePath;
	private static String fullImagePath;
	private static String fullMusicPath;
	public static String DIET_CALORIE_IMAGE_MAX_HEIGHT="diet_calorie_image_max_height";
	public static String DIET_CALORIE_IMAGE_MAX_WIDTH="diet_calorie_image_max_width";
	
	public static String LUNTAN_IMAGE_MAX_HEIGHT="luntan_image_max_height";
	public static String LUNTAN_IMAGE_MAX_WIDTH="luntan_image_max_width";
	
	private static Properties props;
	static {
		refresh();
	}

	public static void refresh() {
		props = new Properties();
		try {
			props.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("config/constants.properties"));
			fullFilePath=null;
			fullImagePath=null;
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static String getValue(String key) {
		return props.getProperty(key);
	}
	
	public static String getFullImagePath(){
		if (fullImagePath==null) {
			fullImagePath= new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST))
					.append(Constants.getValue(Constants.IMG_PATH)).toString();
		}
		return fullImagePath;
	}
	public static String getFullFilePath(){
		if (fullFilePath==null) {
			fullFilePath=new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST))
					.append(Constants.getValue(Constants.FILE_PATH)).toString();
		}
		return fullFilePath;
	}
	
	public static String getFullMusicPath(){
		if (fullMusicPath==null) {
			fullMusicPath=new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST))
					.append(Constants.getValue(Constants.MUSIC_PATH)).toString();
		}
		return fullMusicPath;
	}
	
	public static void main(String[] args){
		System.out.println("STATIC_HOST:"+getValue(STATIC_HOST));
		System.out.println("STATIC_HOST:"+new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST)).append(Constants.getValue(Constants.IMG_PATH)).toString());
		System.out.println("STATIC_HOST:"+new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST)).append(Constants.getValue(Constants.FILE_PATH)).toString());
		System.out.println("STATIC_HOST:"+new StringBuilder().append(Constants.getValue(Constants.STATIC_HOST)).append(Constants.getValue(Constants.MUSIC_PATH)).toString());
	}
	
}

配置文件jdbc.properties

driver=com.mysql.jdbc.Driver
url=jdbc\:mysql\://192.168.0.105\:3306/huidaifu_music?useUnicode\=true&characterEncoding\=utf-8&rewriteBatchedStatements\=true
#url=jdbc\:mysql\://182.92.109.146\:3306/huidaifu?useUnicode\=true&characterEncoding\=utf-8&rewriteBatchedStatements\=true
#url=jdbc\:mysql\://182.92.215.139\:3306/huidaifu_music?useUnicode\=true&characterEncoding\=utf-8&rewriteBatchedStatements\=true
username=root
password=root
#username=jemer
#password=3c905b43cyy
#username=root 
#password=Jemerapp139
#定义初始连接数
initialSize=0
#定义最大连接数
maxActive=20
#定义最大空闲
maxIdle=20
#定义最小空闲
minIdle=1
#定义最长等待时间
maxWait=60000



#mongodb
mongo_host=192.168.0.105
#mongo_host=182.92.109.146
mongo_port=27017
mongo_db=vegetable
mongo_img_bucket=img
mongo_file_bucket=upfile
mongo_username=jemer
mongo_password=jemer
#mongo_username=jemer
#mongo_password=3c905b43cyy

Database.java读取jdbc.properties文件数据

package com.huidaifu.common.prop;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;

public class Database {
	public static String MONGO_HOST = "mongo_host";
	public static String MONGO_PORT = "mongo_port";
	public static String MONGO_DB = "mongo_db";
	public static String MONGO_IMG_BUCKET = "mongo_img_bucket";
	public static String MONGO_FILE_BUCKET = "mongo_file_bucket";
	public static String MONGO_USERNAME = "mongo_username";
	public static String MONGO_PASSWORD = "mongo_password";

	private static Properties props;
	static {
		refresh();
	}

	public static void refresh() {
		props = new Properties();
		try {
			props.load(Thread.currentThread().getContextClassLoader()
					.getResourceAsStream("config/jdbc.properties"));
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static String getValue(String key) {
		return props.getProperty(key);
	}
	/*
	 * public static void updateProperties(String key,String value) {
	 * props.setProperty(key, value); }
	 */
	public static void main(String[] args){
		System.out.println("MONGO_HOST:"+getValue(MONGO_HOST));
		
	}
	
}

mongoDB.java

根据配置文件的数据连接mongo数据库

对数据库中的图片和文件进行保存删除获取的方法

package com.huidaifu.common;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.UUID;

import org.apache.commons.lang3.math.NumberUtils;
import org.apache.log4j.Logger;

import com.huidaifu.common.prop.Database;
import com.huidaifu.util.UploadUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.gridfs.GridFS;
import com.mongodb.gridfs.GridFSDBFile;
import com.mongodb.gridfs.GridFSInputFile;

public class MongoDb{
	
	private static Logger logger = Logger.getLogger(MongoDb.class);
	
	private String host;
	private String port;
	private String dbName;
	private String imgBucket;
	private GridFS gridFSImg;
	private String fileBucket;
	private GridFS gridFSFile;
	
	private static MongoDb mongoDb;
	
	private MongoDb(){
		host = Database.getValue(Database.MONGO_HOST);
		port = Database.getValue(Database.MONGO_PORT);
		dbName = Database.getValue(Database.MONGO_DB);
		imgBucket = Database.getValue(Database.MONGO_IMG_BUCKET);
		fileBucket = Database.getValue(Database.MONGO_FILE_BUCKET);
		Mongo mongo = null;
		try {
			mongo = new Mongo(host, NumberUtils.toInt(port,27017));
			DB db = mongo.getDB(dbName);
			db.authenticate(Database.getValue(Database.MONGO_USERNAME), Database.getValue(Database.MONGO_PASSWORD).toCharArray());
			gridFSImg = new GridFS(db, imgBucket);
			gridFSFile = new GridFS(db,fileBucket);
		} catch (UnknownHostException e) {
			logger.error("MongoDb连接失败！");
			e.printStackTrace();
		}
	}
	
	public static MongoDb getInstance(){
		if(mongoDb==null){
			mongoDb = new MongoDb();
		}
		return mongoDb;
	}
	
	/**
	 * 保存图片，请确保图片名filename唯一
	 * @param in
	 * @param filename
	 * @param contentType
	 * @return
	 * @throws IOException
	 */
	public String saveImg(InputStream in, String filename, String contentType) throws IOException{
		String id = UUID.randomUUID().toString().replace("-", "");
		GridFSInputFile inputFile = gridFSImg.createFile(in);
		inputFile.setId(id);
		inputFile.setFilename(filename);
		inputFile.setContentType(contentType);
		inputFile.put("md5", id);
		inputFile.put("uploadDate", new Date());
		inputFile.save();
		return id;
	}
	
	/**
	 * 保存图片，请确保图片名filename唯一
	 * @param img
	 * @param filename
	 * @param contentType
	 * @return
	 * @throws IOException
	 */
	public String saveImg(File img, String filename, String contentType) throws IOException{
		String id = UUID.randomUUID().toString().replace("-", "");
		GridFSInputFile inputFile = gridFSImg.createFile(img);
		inputFile.setId(id);
		inputFile.setFilename(filename);
		inputFile.setContentType(contentType);
		inputFile.put("md5", id);
		inputFile.put("uploadDate", new Date());
		inputFile.save();
		return id;
	}

	/**
	 * 删除图片
	 * @param id
	 * @return
	 * @throws IOException
	 */
	public boolean deleteImgById(String id) throws IOException{
		DBObject query = new BasicDBObject("_id", id);
		GridFSDBFile gridFSDBFile = gridFSImg.findOne(query);
		if(gridFSDBFile != null){
			gridFSImg.remove(gridFSDBFile);
		}
		return true;
	}
	
	/**
	 * 删除图片
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public boolean deleteImgByFilename(String filename) throws IOException{
		DBObject query = new BasicDBObject("filename", filename);
		GridFSDBFile gridFSDBFile = gridFSImg.findOne(query);
		if(gridFSDBFile != null){
			gridFSImg.remove(gridFSDBFile);
		}
		return true;
	}
	
	/**
	 * 获取图片
	 * @param id
	 * @return
	 */
	public GridFSDBFile findImgById(String id) {
		DBObject query = new BasicDBObject("_id", id);
		GridFSDBFile gridFSDBFile = gridFSImg.findOne(query);
		return gridFSDBFile;
	}
	
	/**
	 * 获取图片
	 * @param filename
	 * @return
	 */
	public GridFSDBFile findImgByFilename(String filename) {
		DBObject query = new BasicDBObject("filename", filename);
		GridFSDBFile gridFSDBFile = gridFSImg.findOne(query);
		return gridFSDBFile;
	}
	
	
	
	
	
	
	/**
	 * 保存文件，请确保文件名filename唯一
	 * @param in
	 * @param filename
	 * @param contentType
	 * @return
	 * @throws IOException
	 */
	public String saveFile(InputStream in, String filename, String contentType) throws IOException{
		String id = UUID.randomUUID().toString().replace("-", "");
		GridFSInputFile inputFile = gridFSFile.createFile(in);
		inputFile.setId(id);
		inputFile.setFilename(filename);
		inputFile.setContentType(contentType);
		inputFile.put("md5", id);
		inputFile.put("uploadDate", new Date());
		inputFile.save();
		return id;
	}
	
	/**
	 * 保存文件，请确保文件名filename唯一
	 * @param file
	 * @param filename
	 * @param contentType
	 * @return
	 * @throws IOException
	 */
	public String saveFile(File file, String filename, String contentType) throws IOException{
		String id = UUID.randomUUID().toString().replace("-", "");
		GridFSInputFile inputFile = gridFSFile.createFile(file);
		inputFile.setId(id);
		inputFile.setFilename(filename);
		inputFile.setContentType(contentType);
		inputFile.put("md5", id);
		inputFile.put("uploadDate", new Date());
		inputFile.save();
		return id;
	}

	/**
	 * 删除文件
	 * @param id
	 * @return
	 * @throws IOException
	 */
	public boolean deleteFileById(String id) throws IOException{
		DBObject query = new BasicDBObject("_id", id);
		GridFSDBFile gridFSDBFile = gridFSFile.findOne(query);
		if(gridFSDBFile != null){
			gridFSFile.remove(gridFSDBFile);
		}
		return true;
	}
	
	
	
	/**
	 * 删除图片
	 * @param filename
	 * @return
	 * @throws IOException
	 */
	public boolean deleteFileByFilename(String filename) throws IOException{
		DBObject query = new BasicDBObject("filename", filename);
		GridFSDBFile gridFSDBFile = gridFSFile.findOne(query);
		if(gridFSDBFile != null){
			gridFSFile.remove(gridFSDBFile);
		}
		return true;
	}
	
	/**
	 * 获取图片
	 * @param id
	 * @return
	 */
	public GridFSDBFile findFileById(String id) {
		DBObject query = new BasicDBObject("_id", id);
		GridFSDBFile gridFSDBFile = gridFSFile.findOne(query);
		return gridFSDBFile;
	}
	
	/**
	 * 获取图片
	 * @param filename
	 * @return
	 */
	public GridFSDBFile findFileByFilename(String filename) {
		DBObject query = new BasicDBObject("filename", filename);
		GridFSDBFile gridFSDBFile = gridFSFile.findOne(query);
		return gridFSDBFile;
	}
}

上传图片根据filename保存图片

	private MultipartFile imgFile;
	
	public Map<String, Object> getProperties() {
		return properties;
	}

	public void setProperties(Map<String, Object> properties) {
		this.properties = properties;
	}
	
	public void put(String key,Object value){
		properties.put(key, value);
	}
	
	public Object get(String key){
		return properties.get(key);
	}

MultipartFile file = food.getImgFile();
String filename=file.getOriginalFilename();  
String fmt = file.getContentType();
InputStream is = file.getInputStream();
filename=UploadUtil.getUUIDName(filename);
MongoDb.getInstance().saveImg(is, filename, fmt);
food.setImg(filename);

获取图片

web.xml配置过滤路径

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
  <display-name></display-name>	
   	<!-- Spring和mybatis的配置文件 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:config/spring-mybatis.xml</param-value>
	</context-param>
	<!-- 加载log4j.properties -->
   <context-param>
   <param-name>log4jConfigLocation</param-name>
   <param-value>classpath:config/log4j.properties</param-value>
   </context-param>
   <!-- 定义LOG4J监听器 --> 
   <listener>
   <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
   </listener>
	<!-- 编码过滤器 -->
	<filter>
		<filter-name>encodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<async-supported>true</async-supported>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<filter-mapping>
		<filter-name>encodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	
	
	 <servlet>
    <servlet-name>autoLoadServlet</servlet-name>
    <servlet-class>web.AutoLoadServlet</servlet-class>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>autoLoadServlet</servlet-name>
    <url-pattern>/autoLoadServlet</url-pattern>
  </servlet-mapping>
	
	<!-- servlet代理注入dao -->
	<servlet>
    <servlet-name>frontRcvResponse</servlet-name>
    <servlet-class>com.huidaifu.unionpay.acp.demo.DelegatingServletProxy</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>frontRcvResponse</servlet-name>
    <url-pattern>/frontRcvResponse</url-pattern>
  </servlet-mapping>
  <servlet>
    <servlet-name>backRcvResponse</servlet-name>
    <servlet-class>com.huidaifu.unionpay.acp.demo.DelegatingServletProxy</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>backRcvResponse</servlet-name>
    <url-pattern>/backRcvResponse</url-pattern>
  </servlet-mapping>
	
	
	<!-- Spring监听器 -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
	<!-- 防止Spring内存溢出监听器 -->
	<listener>
		<listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>
	</listener>

	<!-- Spring MVC servlet -->
	<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:config/spring-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
		<async-supported>true</async-supported>
	</servlet>
	<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
		<url-pattern>*.do</url-pattern>
	</servlet-mapping>
  	
  	<filter>

        <filter-name>DelegatingFilterProxy</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
        <init-param>
            <param-name>targetBeanName</param-name>
            <param-value>customerFilter</param-value>
        </init-param>
        <init-param>
            <param-name>targetFilterLifecycle</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>indexPath</param-name>
            <param-value>/pages/error/500.html</param-value>
        </init-param>
        <init-param>
            <param-name>ignoreList</param-name>
            <param-value></param-value>
        </init-param>

</filter>

	<!-- 登录过滤器 -->
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/customer/*</url-pattern>
    </filter-mapping> 
    
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/luntan/*</url-pattern>
    </filter-mapping> 
    
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/user/*</url-pattern>
    </filter-mapping> 
    
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/personal/*</url-pattern>
    </filter-mapping> 
    
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/return/*</url-pattern>
    </filter-mapping> 
    
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/home/*</url-pattern>
    </filter-mapping> 
    <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/food/*</url-pattern>
    </filter-mapping> 
   <filter-mapping>
        <filter-name>DelegatingFilterProxy</filter-name>
        <url-pattern>/sport/*</url-pattern>
    </filter-mapping> 

    <filter>
        <filter-name>customerFilter</filter-name>
        <filter-class>com.huidaifu.filter.CustomerFilter</filter-class>
    </filter>
  	

	<filter>  
    <filter-name>mongoImage</filter-name>  
    <filter-class>com.huidaifu.filter.MongoImageFilter</filter-class>  
  </filter>
  <filter-mapping>  
    <filter-name>mongoImage</filter-name>  
    <url-pattern>/files/img/*</url-pattern>  
  </filter-mapping>
  
  <filter>  
    <filter-name>mongoFile</filter-name>  
    <filter-class>com.huidaifu.filter.MongoFileFilter</filter-class>  
  </filter>
  <filter-mapping>  
    <filter-name>mongoFile</filter-name>  
    <url-pattern>/files/upfile/*</url-pattern>  
  </filter-mapping>
  
	<!-- 配置SESSION超时，单位是分钟 -->
	<session-config>
		<session-timeout>30</session-timeout>
	</session-config>
  
   <!-- 配置欢迎页面 -->
 
  <!-- <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list> -->
  
  
</web-app>

图片过滤器，利用mongodb根据filename获取图片并显示

package com.huidaifu.filter;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.math.BigDecimal;

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.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.io.IOUtils;

import com.huidaifu.common.MongoDb;
import com.mongodb.gridfs.GridFSDBFile;

/**
 * mongo 图片过滤器
 * @author Administrator
 *
 */
public class MongoImageFilter implements Filter  {

	private MongoDb mongoDb;

	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
			FilterChain chain) throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest)servletRequest;  
		HttpServletResponse response = (HttpServletResponse)servletResponse; 
		String uri = request.getRequestURI();
		if(uri.startsWith("/files/img/")){
			int n = uri.lastIndexOf('?');
			String filename = uri.substring(uri.lastIndexOf('/')+1, n>0 ? n:uri.length());
			GridFSDBFile file = mongoDb.findImgByFilename(filename);
			if(file != null){
				InputStream input = file.getInputStream();
				response.setContentType(file.getContentType());
				OutputStream output = response.getOutputStream();
				IOUtils.copy(input, output);
			}
		}else{
			chain.doFilter(request, response);
		}
	}

	public void init(FilterConfig filterConfig) throws ServletException {
		mongoDb = MongoDb.getInstance();
		
	}

	public void destroy() {
		// TODO Auto-generated method stub
	}

}