崛起于Springboot2.X之集成读写分离MongoDB使用Client增删改查(25)

最新推荐文章于 2023-01-12 17:51:27 发布
最新推荐文章于 2023-01-12 17:51:27 发布
阅读量1k 收藏
点赞数
文章标签： java 数据库 json
原文链接：https://my.oschina.net/mdxlcj/blog/1859527
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

转载请注明出处！使用MongoClient操作数据库，因为标题最多50个字符，字数不够。

1、添加pom依赖

    mongodb集成springboot的依赖以及读写分离需要的一些工具包以及其他开发工具包

<dependency>
   <groupId>org.mongodb</groupId>
   <artifactId>mongo-java-driver</artifactId>
   <version>3.4.2</version>
</dependency>
<dependency>
   <groupId>com.alibaba</groupId>
   <artifactId>fastjson</artifactId>
   <version>1.2.7</version>
</dependency>
<dependency>
   <groupId>org.springside</groupId>
   <artifactId>springside3-core</artifactId>
   <version>3.3.4</version>
</dependency>
<dependency>
   <groupId>commons-lang</groupId>
   <artifactId>commons-lang</artifactId>
   <version>2.5</version>
</dependency>
<dependency>
   <groupId>com.google.code.morphia</groupId>
   <artifactId>morphia</artifactId>
   <version>0.99</version>
</dependency>
<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.16</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
2、添加配置文件
spring.data.mongodb.uri=mongodb://localhost:27017/xbl

#下面是主库，读库，写库
mongoDBName=xbl
mongoDBIP=127.0.0.1
mongoDBPORT=27017
mongoDBCheck=(drop|remove|kill|shutdown|rename|update|insert|save|add|use)
mongodbConnectionsCount=1000

mongoDBWriteName=xbl
mongoDBWriteIP=127.0.0.1
mongoDBWritePORT=27017
mongoDBWriteCheck=(drop|remove|kill|shutdown|rename|update|insert|save|add|use)
mongodbWriteConnectionsCount=1000

mongoDBReadName=xbl
mongoDBReadIP=127.0.0.1
mongoDBReadPORT=27017
mongoDBReadCheck=(drop|remove|kill|shutdown|rename|update|insert|save|add|use)
mongodbReadConnectionsCount=1000
3、配置类
public abstract class AbstarctMongoDBConnection {

   protected static Logger logger = LoggerFactory.getLogger(AbstarctMongoDBConnection.class);

   protected MongoClient instance = null;

   protected boolean isRenew = false;
   
   protected volatile boolean isShard = true;
   
   public abstract MongoClient getMongoClient();

   public DB getDB(String dbname) {
      return getMongoClient().getDB(dbname);
   }

   public Datastore getDataStore(String dbname) {
      Morphia morphia = new Morphia();
      return morphia.createDatastore(getMongoClient(), dbname);
   }

   public boolean isShard() {
      return isShard;
   }

}
public class MongoDBConnection extends AbstarctMongoDBConnection{

   protected static Logger logger = LoggerFactory.getLogger(MongoDBConnection.class);

   /**
    * Mongodb连接实例
    * @return
    */
   public MongoClient getMongoClient() {
      if(super.instance==null){
         try {
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            build.connectionsPerHost(Integer.valueOf(KeegooConfig.mongodbConnectionsCount));//连接数
            build.connectTimeout(5000);//连接超时时间
            build.maxWaitTime(10000);//最大等待时间
            build.socketKeepAlive(true);//保持连接
            build.socketTimeout(0);//0，不限时间
            build.threadsAllowedToBlockForConnectionMultiplier(50);
            MongoClientOptions options = build.build();
            List<ServerAddress> addresses = new ArrayList<ServerAddress>();
            if (DataTypeUtils.isNotEmpty(KeegooConfig.mongoDBHOSTS)) {
               String[] hosts = KeegooConfig.mongoDBHOSTS.split(",");
               String[] ports = KeegooConfig.mongoDBPORTS.split(",");
               for (int i = 0; i < hosts.length; i++) {
                  ServerAddress address = new ServerAddress(hosts[i], Integer.valueOf(ports[i]));
                  addresses.add(address);
               }
               super.instance = new MongoClient(addresses, options);
               super.isShard = true;
            }else{
               ServerAddress addr = new ServerAddress(KeegooConfig.mongoDBIP, Integer.valueOf(KeegooConfig.mongoDBPORT));
               super.instance = new MongoClient(addr, options);
               super.isShard = false;
            }
         } catch (NumberFormatException e) {
            logger.error("Mongon数据库服务器连接失败！", e);
         }
      }
      return super.instance;
   }
}
public class MongoDBReadConnection extends AbstarctMongoDBConnection{

   protected static Logger logger = LoggerFactory.getLogger(MongoDBReadConnection.class);
   
   /**
    * Mongodb连接实例
    * 
    * @return
    */
   public MongoClient getMongoClient() {
      if(super.instance==null){
         try {
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            //build.autoConnectRetry(true);//是否连接自动重试
            build.connectionsPerHost(Integer.valueOf(KeegooConfig.mongodbReadConnectionsCount));//连接数
            build.connectTimeout(5000);//连接超时时间
            build.maxWaitTime(10000);//最大等待时间
            build.socketKeepAlive(true);//保持连接
            build.socketTimeout(0);//0，不限时间
            //build.maxAutoConnectRetryTime(1);//最大重试时间，单位秒
            build.threadsAllowedToBlockForConnectionMultiplier(50);
            MongoClientOptions options = build.build();

            List<ServerAddress> addresses = new ArrayList<ServerAddress>();
            if (DataTypeUtils.isNotEmpty(KeegooConfig.mongoDBReadHOSTS)) {
               String[] hosts = KeegooConfig.mongoDBReadHOSTS.split(",");
               String[] ports = KeegooConfig.mongoDBReadPORTS.split(",");
               for (int i = 0; i < hosts.length; i++) {
                  ServerAddress address = new ServerAddress(hosts[i], Integer.valueOf(ports[i]));
                  addresses.add(address);
               }
               super.instance = new MongoClient(addresses, options);
               super.isShard = true;
            }else{
               ServerAddress addr = new ServerAddress(KeegooConfig.mongoDBReadIP, Integer.valueOf(KeegooConfig.mongoDBReadPORT));
               super.instance = new MongoClient(addr, options);
               super.isShard = false;
            }
         } catch (NumberFormatException e) {
            logger.error("Mongon数据库服务器连接失败！", e);
         }
      }
      return super.instance;
   }

}
public class MongoDBWriteConnection extends AbstarctMongoDBConnection{

   protected static Logger logger = LoggerFactory.getLogger(MongoDBReadConnection.class);
   /**
    * Mongodb连接实例
    * 
    * @return
    */
   public MongoClient getMongoClient() {
      if(super.instance==null){
         try {
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
//          build.autoConnectRetry(true);//是否连接自动重试
            build.connectionsPerHost(Integer.valueOf(KeegooConfig.mongodbWriteConnectionsCount));//连接数
            build.connectTimeout(5000);//连接超时时间
            build.maxWaitTime(10000);//最大等待时间
            build.socketKeepAlive(true);//保持连接
            build.socketTimeout(0);//0，不限时间
            //build.maxAutoConnectRetryTime(1);//最大重试时间，单位秒
            build.threadsAllowedToBlockForConnectionMultiplier(50);
            MongoClientOptions options = build.build();
            
            List<ServerAddress> addresses = new ArrayList<ServerAddress>();
            if (DataTypeUtils.isNotEmpty(KeegooConfig.mongoDBWriteHOSTS)) {
               String[] hosts = KeegooConfig.mongoDBWriteHOSTS.split(",");
               String[] ports = KeegooConfig.mongoDBWritePORTS.split(",");
               for (int i = 0; i < hosts.length; i++) {
                  ServerAddress address = new ServerAddress(hosts[i], Integer.valueOf(ports[i]));
                  addresses.add(address);
               }
               super.instance = new MongoClient(addresses, options);
               super.isShard = true;
            }else{
               ServerAddress addr = new ServerAddress(KeegooConfig.mongoDBWriteIP, Integer.valueOf(KeegooConfig.mongoDBWritePORT));
               super.instance = new MongoClient(addr, options);
               super.isShard = false;
            }
         } catch (NumberFormatException e) {
            logger.error("Mongon数据库服务器连接失败！", e);
         }
      }
      return super.instance;
   }

}
public interface IMongoDAO {

   /**
    * save(新增)
    * @param model
    * @param json
    * @return
    * @throws Exception
    *             String
    * @exception
    * @since 1.0.0
    */
   public JSONObject save(String model, String json) throws ServiceException;

   public JSONObject save(String model, JSONArray list) throws ServiceException ;

   /**
    * delete(删除)
    * @param model
    * @param id
    * @return String
    * @exception
    * @since 1.0.0
    */
   public JSONObject delete(String model, String id) throws ServiceException;

   /**
    * update(更新)
    * @param model
    * @param json
    * @param id
    * @return String
    * @exception
    * @since 1.0.0
    */
   public JSONObject update(String model, String json, String id) throws ServiceException;
   
   public JSONObject updateUnset(String model, String json, String id) ;

   /**
    * inc(自增长)
    * @param model
    * @param json
    * @param id
    * @return String
    * @exception
    * @since 1.0.0
    */
   public JSONObject inc(String model, String json, String id) throws ServiceException;
   
   /**
    * 批量自增长
    * @param model
    * @param json
    * @param condition
    * @return
    * @throws ServiceException
    */
   public JSONObject batchInc(String model, String json, JSONObject condition) throws ServiceException;
   
   /**
    * 聚合函数
    * @param model 表
    * @param query 查询条件
    * @param sort 排序
    * @param skip 分页
    * @param limit 分页
    * @return
    * @throws Exception
    */
   public JSONArray aggregate(String model, String query, String sort, int skip, int limit) throws Exception ;
   /**
    * 聚合函数
    * aggregate:
    * @author sid
    * @param model
    * @param conditions
    * 通过管道操作；具体可用管道如下：
    * $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
    * $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
    * $limit：用来限制MongoDB聚合管道返回的文档数。
    * $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
    * $unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
    * $group：将集合中的文档分组，可用于统计结果。
    * $sort：将输入文档排序后输出。
    * $geoNear：输出接近某一地理位置的有序文档。
    * 下面是表达式内的可以函数
    * $sum、$avg、$min、$max、$push、$addToSet、$first、$last
    * @return
    * @throws Exception
    */
   public JSONArray aggregate(String model, List<String> conditions) ;
   /**
    * 聚合函数
    * @param model
    * @param pipeline
    * @return
    * @throws Exception
    */
   public JSONArray aggregate(String model, String pipeline) throws Exception;
   
   /**
    * get(按id查找)
    * @param model
    * @param id
    * @return String
    * @exception
    * @since 1.0.0
    */
   public String get(String model, String id) throws ServiceException;

   /**
    * find(高级查询)
    * @param query
    *            查询条件
    * @param fields
    *            返回字段
    * @param orderBy
    *            排序条件
    * @param model
    *            查询模型
    * @param numToSkip
    *            跳过条数
    * @param batchSize
    *            返回条数
    * @return List<DBObject>
    * @exception
    * @since 1.0.0
    */
   public DBObject find(String where, String fields, String orderBy, String model, int skip, int size) ;
   /**
    * find(高级查询)
    * @param query
    *            查询条件
    * @param fields
    *            返回字段
    * @param orderBy
    *            排序条件
    * @param model
    *            查询模型
    * @return List<DBObject>
    * @exception
    * @since 1.0.0
    */
   public DBObject find(String where, String fields, String orderBy, String model) ;

   /**
    * distinct(高级查询)
    * @param query
    *            查询条件
    * @param fieldName
    *            指定字段
    * @param model
    *            查询模型
    * @return List<DBObject>
    * @exception
    * @since 1.0.0
    */
   public List<?> distinct(String query, String fieldName, String model) ;

   /**
    * eval(在mongo Server上执行js函数)
    * @param function
    * @param args
    * @return String
    * @exception
    * @since 1.0.0
    */
   public String eval(String function, String json) ;
   
   /**
    * 原子修改操作
    * @param model
    * @param where
    * @param update
    * @param returnNew true返回修改后数据,false 返回修改前的数据
    * @param upsert true 修改的记录不存在则新增一条
    * @return
    */
   public JSONObject findAndModify(String model, String where, String update, boolean returnNew, boolean upsert);

   /**
    * 插入
    * @param model
    *            集合名
    * @param obj
    *            新文档
    */

   public WriteResult insert(String model, DBObject obj) ;

   /**
    * 查询
    * @param model
    *            集合名
    * @param obj
    *            条件文档
    * @return DBCursor 游标
    */
   public DBCursor find(String model, DBObject obj) ;

   /**
    * 查询unique
    * 
    * @param collection
    *            集合名
    * @param obj
    *            条件文档
    * @return DBObject 文档对象
    */
   public DBObject findOne(String model, DBObject obj) ;

   /**
    * 查询
    * 
    * @param model
    *            集合名
    * @param key
    *            查询条件键
    * @param value
    *            查询条件值
    * @return DBCursor 游标
    */
   public DBCursor find(String model, String key, String value) ;
   
   public DBCursor find(String model, String key, Object value) ;

   /**
    * 查询unique
    * 
    * @param model
    *            集合名
    * @param key
    *            查询条件键
    * @param value
    *            查询条件值
    * @return DBObject 文档对象
    */
   public DBObject findOne(String model, String key, String value) ;

   public JSONObject updateByCondition(String model, String json, String condition);
   
}
public class MongoDAO extends AbstractMongoDAO{
   
   private static MongoDAO instance = new MongoDAO();
   
   private MongoDAO(){
      super.dbConnection = new MongoDBConnection();
      super.db = super.dbConnection.getDB(KeegooConfig.mongoDBName);
      super.db.setReadPreference(ReadPreference.nearest());
   }
   
   public static MongoDAO getInstance(){
      return instance;
   }
   
}
public class MongoDAOFactory {

   /**
    * 获取读写
    * @return
    */
   public static IMongoDAO getMongoDAO(){
      return MongoDAO.getInstance();
   }
   /**
    * 获取只读
    * @return
    */
   public static IMongoDAO getMongoReadDAO(){
      return MongoReadDAO.getInstance();
   }
   /**
    * 获取只写
    * @return
    */
   public static IMongoDAO getMongoWriteDAO(){
      return MongoWriterDAO.getInstance();
   }
}
public class MongoReadDAO extends AbstractMongoDAO{

   private static MongoReadDAO instance = new MongoReadDAO();
   
   private MongoReadDAO(){
      super.dbConnection = new MongoDBReadConnection();
      super.db = super.dbConnection.getDB(KeegooConfig.mongoDBName);
      super.db.setReadPreference(ReadPreference.secondaryPreferred());
   }
   
   public static MongoReadDAO getInstance(){
      return instance;
   }
}
public class MongoWriterDAO extends AbstractMongoDAO{

   private static MongoWriterDAO instance = new MongoWriterDAO();
   
   private MongoWriterDAO(){
      super.dbConnection = new MongoDBWriteConnection();
      super.db = super.dbConnection.getDB(KeegooConfig.mongoDBName);
      super.db.setReadPreference(ReadPreference.primaryPreferred());
   }
   
   public static MongoWriterDAO getInstance(){
      return instance;
   }
}

 primary 主节点，默认模式，读操作只在主节点，如果主节点不可用，报错或者抛出异常。 primaryPreferred 首选主节点，大多情况下读操作在主节点，如果主节点不可用，如故障转移，读操作在从节点。 secondary 从节点，读操作只在从节点， 如果从节点不可用，报错或者抛出异常。 secondaryPreferred 首选从节点，大多情况下读操作在从节点，特殊情况（如单主节点架构）读操作在主节点。 nearest 最邻近节点，读操作在最邻近的成员，可能是主节点或者从节点 

4、工具类
public class KeegooConfig {
   
   public static String mongoDBHOSTS;
   public static String mongoDBPORTS;
   public static String mongoDBIP;
   public static String mongoDBPORT;
   /** mogoDB 名称 */
   public static String mongoDBName;
   public static String mongoDBCheck;
   /** mongodb连接数 */
   public static String mongodbConnectionsCount;
   
   /**
    * mongodb写
    */
   public static String mongoDBWriteHOSTS;
   public static String mongoDBWritePORTS;
   public static String mongoDBWriteIP;
   public static String mongoDBWritePORT;
   public static String mongoDBWriteName;
   public static String mongoDBWriteCheck;
   public static String mongodbWriteConnectionsCount;
   
   /**
    * mongodb读
    */
   public static String mongoDBReadHOSTS;
   public static String mongoDBReadPORTS;
   public static String mongoDBReadIP;
   public static String mongoDBReadPORT;
   public static String mongoDBReadName;
   public static String mongoDBReadCheck;
   public static String mongodbReadConnectionsCount;
   
   /** 主机HOST参数 **/
   public static String HOST_NAME;
   public static String HOST_NAME_ENCODE;
   
   static{
      try {
         Properties p = PropertiesUtils.loadProperties("application.properties");
         /**
          * mongodb配置
          */
         mongoDBName= p.getProperty("mongoDBName");
         mongodbConnectionsCount= p.getProperty("mongodbConnectionsCount");
         mongoDBHOSTS = p.getProperty("mongoDBHOSTS");
         mongoDBPORTS = p.getProperty("mongoDBPORTS");
         mongoDBIP= p.getProperty("mongoDBIP");
         mongoDBPORT= p.getProperty("mongoDBPORT");
         mongoDBCheck= p.getProperty("mongoDBCheck");
         
         mongoDBWriteName= p.getProperty("mongoDBWriteName");
         mongodbWriteConnectionsCount= p.getProperty("mongodbWriteConnectionsCount");
         mongoDBWriteHOSTS = p.getProperty("mongoDBWriteHOSTS");
         mongoDBWritePORTS = p.getProperty("mongoDBWritePORTS");
         mongoDBWriteIP= p.getProperty("mongoDBWriteIP");
         mongoDBWritePORT= p.getProperty("mongoDBWritePORT");
         mongoDBWriteCheck= p.getProperty("mongoDBWriteCheck");
         
         mongoDBReadName= p.getProperty("mongoDBReadName");
         mongodbReadConnectionsCount= p.getProperty("mongodbReadConnectionsCount");
         mongoDBReadHOSTS = p.getProperty("mongoDBReadHOSTS");
         mongoDBReadPORTS = p.getProperty("mongoDBReadPORTS");
         mongoDBReadIP= p.getProperty("mongoDBReadIP");
         mongoDBReadPORT= p.getProperty("mongoDBReadPORT");
         mongoDBReadCheck= p.getProperty("mongoDBReadCheck");
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}
public class Constant {
   
   private static Resource resource = null;
   private static Properties property = null;
   
   static{
       try {
          resource = new ClassPathResource("/application.properties");
         property = PropertiesLoaderUtils.loadProperties(resource);
      } catch (IOException e) {
      }
   }
   
   /**
    * 创建时间
    */
   public static final String CREATED_AT = "createdAt";
   
   /**
    * 更新时间
    */
   public static final String UPDATED_AT = "updatedAt";
   
   /**
    * 主键key
    */
   public static final String OBJECTID = "objectId";
}
public class DataTypeUtils {


   /**
    * 判断当前参数列表是否均不为空
    * @param objects
    * @return
    */
   @SuppressWarnings("rawtypes")
   public static boolean isNotEmpty(Object... objects) {
      if (objects == null) {
         return false;
      }
      for (Object obj : objects) {
         if (obj == null) {
            return false;
         }
         if (obj instanceof String) {
            if ("null".equals(((String) obj).trim())||"".equals(((String) obj).trim())) {
               return false;
            }
         }
         if (obj instanceof List){
            if (((List) obj).size()==0) {
               return false;
            }
         }
         if (obj instanceof Iterable){
            if (!((Iterable) obj).iterator().hasNext()) {
               return false;
            }
         }
         if (obj instanceof Map){
            if (((Map) obj).keySet().isEmpty()) {
               return false;
            }
         }
      }
      
      return true;
   }

   /**
    * 填充字符串；不足自动前置补充
    * @param source
    * @param length
    * @param sign
    * @return
    */
   public static String fillDataPre(String source,int length,String sign){
      String result = "";
      int num = length-source.length();
      for (int i = 0; i < num; i++) {
         result+=sign;
      }
      result+=source;
      return result;
   }
   
   /**
    * 手机号验证
    * 
    * @param  str
    * @return 验证通过返回true
    */
   public static boolean isMobile(String str) { 
      Pattern p = null;
      Matcher m = null;
      boolean b = false; 
      p = Pattern.compile("^((1[3,5,8][0-9])|(14[5,7])|(17[0,6,7,8]))\\d{8}$"); // 验证手机号
      m = p.matcher(str);
      b = m.matches(); 
      return b;
   }
   
   /**
    * 
    * isBiggerThan:
    *
    * @author sid
    * @param a
    * @param b
    * @return a>b true;a<b false
    */
   public static boolean isBiggerThan(String a,String b){
      return a.compareTo(b)>0?true:false;
   }
   
   public static void main(String[] args) {
      System.out.println(DataTypeUtils.isMobile("15010331011"));
   }
}
public class DateUtils {

   private static Logger logger = Logger.getLogger(DateUtils.class);

   /**
    * yyyy-MM-dd
    */
   public static SimpleDateFormat SDF1 = new SimpleDateFormat("yyyy-MM-dd");
   /**
    * yyyy/MM/dd
    */
   public static SimpleDateFormat SDF2 = new SimpleDateFormat("yyyy/MM/dd");
   /**
    * yyyy-MM-dd HH:mm:ss
    */
   public static SimpleDateFormat SDF3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   /**
    * yyMMddHHmmss
    */
   public static SimpleDateFormat SDF4 = new SimpleDateFormat("yyMMddmmss");
   /**
    * HH:mm yyyy-MM-dd 
    */
   public static SimpleDateFormat SDF5 = new SimpleDateFormat("HH:mm yyyy-MM-dd");
   
   /**
    * yyyy-MM-dd HH:mm
    */
   public static SimpleDateFormat SDF6 = new SimpleDateFormat("yyyy-MM-dd HH:mm");

   /**
    * yyyyMMdd
    */
   public static SimpleDateFormat SDF7 = new SimpleDateFormat("yyyyMMdd");
   
   /**
    * yyyyMMddHHmmss
    */
   public static SimpleDateFormat SDF8 = new SimpleDateFormat("yyyyMMddHHmmss");
   
   /**
    * yyyy-mm-dd-hh
    */
   public static SimpleDateFormat SDF9 = new SimpleDateFormat("yyyy-MM-dd-hh");
   
   /**
    * hh
    */
   public static SimpleDateFormat SDF10 = new SimpleDateFormat("hh");
   
   /**
    * 仅比较年月日 相等
    * 
    * @param d1
    * @param d2
    * @return
    */
   public static boolean isSameDate(Date d1, Date d2) {
      if (d1 == null || d2 == null) {
         logger.debug("isSameDate : 参数有空值，直接返回false");
         return false;
      }
      Calendar c1 = Calendar.getInstance();
      c1.setTime(d1);

      Calendar c2 = Calendar.getInstance();
      c1.setTime(d2);

      return c1.get(Calendar.YEAR) == c2.get(Calendar.YEAR)
            && c1.get(Calendar.MONTH) == c2.get(Calendar.MONTH)
            && c1.get(Calendar.DATE) == c2.get(Calendar.DATE);

   }
   
   /**
    * 
    * getDateAddMinutes:(获取指定时间之后多少分钟的时间). 
    *
    * @author sid
    * @param date
    * @param minutes
    * @return
    */
   public static Date getDateAddMinutes(Date date,int minutes){
      
      Calendar cl = Calendar.getInstance();
      cl.setTime(date);
      cl.add(Calendar.MINUTE , minutes);
      
      return cl.getTime();
   }

   public static Date getDateAddHours(Date date, int hours) {

      Calendar cl = Calendar.getInstance();
      cl.setTime(date);
      cl.add(Calendar.HOUR, hours);

      return cl.getTime();
   }
   
   /**
    * 保留日期 ，把时间设置为 0 <br>
    * HOUR_OF_DAY<br>
    * MINUTE<br>
    * SECOND<br>
    * MILLISECOND<br>
    * 
    * @param d
    * @return
    */
   public static Date clearTime(Date d) {
      Calendar ca = Calendar.getInstance();
      ca.setTime(d);
      ca.set(Calendar.HOUR_OF_DAY, 0);
      ca.set(Calendar.MINUTE, 0);
      ca.set(Calendar.SECOND, 0);
      ca.set(Calendar.MILLISECOND, 0);
      return ca.getTime();
   }

   /**
    * 增加天数(负值为减)
    * 
    * @param d
    * @param dayToAdd
    * @return
    */
   public static Date addDay(Date d, int dayToAdd) {
      Calendar ca = Calendar.getInstance();
      ca.setTime(d);
      ca.add(Calendar.DAY_OF_MONTH, dayToAdd);
      return ca.getTime();
   }
   
   /**
    * 增加天数(负值为减)
    * 
    * @param d
    * @param dayToAdd
    * @return
    */
   public static Date addDay(String d, int dayToAdd) {
      Date date = getYYYY_MM_dd_HH_mm_ssToDate(d);
      Calendar ca = Calendar.getInstance();
      ca.setTime(date);
      ca.add(Calendar.DAY_OF_MONTH, dayToAdd);
      return ca.getTime();
   }

   /**
    * 是否为"今天"
    * 
    * @param d
    * @return
    */
   public static boolean isToday(Date d) {
      return isSameDate(d, new Date());
   }
   public static boolean isToday(String d) {
      return isToday(getYYYY_MM_dd_HH_mm_ssToDate(d));
   }

    /**
     * 是否是指定日期
     *
     * @param date
     * @param day
     * @return
     */
    public static boolean isTheDay(final Date date, final Date day) {
            return date.getTime() >= DateUtils.dayBegin(day).getTime()
                            && date.getTime() <= DateUtils.dayEnd(day).getTime();
    }

    /**
     * 获取指定时间的那天 00:00:00.000 的时间
     *
     * @param date
     * @return
     */
    public static Date dayBegin(final Date date) {
            Calendar c = Calendar.getInstance();
            c.setTime(date);
            c.set(Calendar.HOUR_OF_DAY, 0);
            c.set(Calendar.MINUTE, 0);
            c.set(Calendar.SECOND, 0);
            c.set(Calendar.MILLISECOND, 0);
            return c.getTime();
    }

    /**
     * 获取今天 00:00:00.000 的时间
     *
     * @param date
     * @return
     */
    public static Date dayBegin() {
            return dayBegin(now());
    }

    /**
     * 获取指定时间的那天 23:59:59.999 的时间
     *
     * @param date
     * @return
     */
    public static Date dayEnd(final Date date) {
            Calendar c = Calendar.getInstance();
            c.setTime(date);
            c.set(Calendar.HOUR_OF_DAY, 23);
            c.set(Calendar.MINUTE, 59);
            c.set(Calendar.SECOND, 59);
            c.set(Calendar.MILLISECOND, 999);
            return c.getTime();
    }

    /**
     * 获取今天 23:59:59.999 的时间
     *
     * @param date
     * @return
     */
    public static Date dayEnd() {
            return dayEnd(now());
    }
   
    /**
     * 获取当前时间
     *
     * @return
     */
    public static Date now() {
            return new Date();
    }
    
   /**
    * 取得今天的日期加最小时间
    * @return
    */
   public static String getTheTodayMin() {
      return getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMin(new Date()));
   }
   
   /**
    * 取得今天的日期加最大时间
    * @return
    */
   public static String getTheTodayMax() {
      return getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMax(new Date()));
   }
    
    /**
     * 取得某天的日期加最小时间
     * @return
     */
    public static Date getTheDayMin(Date d) {
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
        String ds = f.format(d) + " 00:00:00";
        try {
            f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return f.parse(ds);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    /**
     * 取得某天的日期加最大时间
     * @return
     */
    public static Date getTheDayMax(Date d) {
        SimpleDateFormat f = new SimpleDateFormat("yyyy-MM-dd");
        String ds = f.format(d) + " 23:59:59";
        try {
            f = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            return f.parse(ds);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    
    public static String getTheDayMax(String d) {
       Date date = getYYYY_MM_dd_HH_mm_ssToDate(d);
       date = getTheDayMax(date);
       return getDateToyyyy_MM_dd_HH_mm_ss(date);
    }
    
    public static String getTheDayMin(String d) {
       Date date = getYYYY_MM_dd_HH_mm_ssToDate(d);
       date = getTheDayMin(date);
       return getDateToyyyy_MM_dd_HH_mm_ss(date);
    }

    /**
     * 
     *  将字符串格式的日期转换为Date型的日期<p>
     *  modify by wjz 0326<p>
     *  考虑到日期格式比较复杂，在转换之前先做如下假定：<p>
     *  都是按照年－月－日的格式排列<p>
     *  年都是4位<p>
     * strToDate:
     *
     * @author sid
     * @param strDate
     * @return
     */
    public static Date strToDate(String strDate) {
        if (strDate == null || strDate.length() < 6) {
            throw new IllegalArgumentException("illeage date format");
        }
        String fmt = "yyyy-MM-dd HH:mm:ss";
        if (strDate.length() == 19) {
            if (strDate.indexOf("-") > 0) {
                fmt = "yyyy-MM-dd HH:mm:ss";
            } else if (strDate.indexOf("/") > 0) {
                fmt = "yyyy/MM/dd HH:mm:ss";
            }
        } else if (strDate.length() == 18) {
            if (strDate.indexOf("-") > 0) {
                fmt = "yyyy-MM-ddHH:mm:ss";
            } else if (strDate.indexOf("/") > 0) {
                fmt = "yyyy/MM/ddHH:mm:ss";
            }
        } else if (strDate.length() == 16) {
            if (strDate.indexOf("-") > 0) {
                fmt = "yyyy-MM-dd HH:mm";
            } else if (strDate.indexOf("/") > 0) {
                fmt = "yyyy/MM/dd HH:mm";
            }
        } else if (strDate.length() == 14) {

            fmt = "yyyyMMddHHmmss";
        } else if (strDate.length() == 10) {
            if (strDate.indexOf("-") > 0) {
                fmt = "yyyy-MM-dd";
            } else if (strDate.indexOf("/") > 0) {
                fmt = "yyyy/MM/dd";
            } else if (strDate.indexOf(".") > 0) {
                fmt = "yyyy.MM.dd";
            }
        } else if (strDate.length() == 8) {
            if (strDate.indexOf("-") > 0) {
                fmt = "yy-MM-dd";
            } else if (strDate.indexOf("/") > 0) {
                fmt = "yy/MM/dd";
            } else if (strDate.indexOf(".") > 0) {
                fmt = "yy.MM.dd";
            } else {
                fmt = "yyyyMMdd";
            }

        }

        SimpleDateFormat formatter = new SimpleDateFormat(fmt);
        ParsePosition pos = new ParsePosition(0);
        Date strtodate = formatter.parse(strDate, pos);
        return strtodate;
    }
    
   /**
    * 日期转字符串
    * 
    * @param date
    * @param format
    * @return
    */
   public static String dateToString(Date date, String format) {
      if (date == null) {
         return "";
      }
      if (format == null) {
         format = "yyyy-MM-dd hh:mm:ss";
      }
      SimpleDateFormat df = new SimpleDateFormat(format);
      return df.format(date);
   }

   /**
    * 日期转字符串
    *  12小时制
    * @param date
    * @param format
    * @return
    */
   public static String dateToString(Date date) {
      if (date == null) {
         return "";
      }
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      return df.format(date);
   }
   
   /**
    * add by Bill
    * 2011-07-07
    *  格式化为yyyyMMddHHmmss的形式
    * @param datestr
    * @return
    */
   public static String dateToString(){
      return SDF4.format(new Date());
   }
   
   /**
    *  add by Bill
    * 日期转字符串
    *  24小时制
    * @param date
    * @param format
    * @return
    */
   public static String date24ToString(Date date) {
      if (date == null) {
         return "";
      }
      SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      return df.format(date);
   }

   public static String dataToStringYMD(){
      return SDF7.format(new Date());
   }
   
   /**
    * 日期转时间戳
    * 
    * @param date
    * @return
    */
   public static long dateToTimeMillis(Date date) {
      if (date == null) {
         return 0;
      }
      return date.getTime() / 1000;
   }
   
   /**
    * add by Bill
    * 2011-07-07
    * @param datestr
    * @return
    */
   public static Date StringToDate(String datestr){
      Date dt=null;
      if(datestr==null || "".equals(datestr)){
         dt = new Date();
      }
      try {
         dt = SDF3.parse(datestr);
      } catch (ParseException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      
      return dt;
   }
   
   public static Date String2Date(String datestr){
      Date dt=null;
      if(datestr==null || "".equals(datestr)){
         dt = new Date();
      }
      try {
         dt = SDF6.parse(datestr);
      } catch (ParseException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      
      return dt;
   }

   public static boolean getIsSaleBegin() {
      Calendar calendar = Calendar.getInstance();
      calendar.add(Calendar.DAY_OF_MONTH, 0);
      Date date = DateUtils.clearTime(calendar.getTime());
      try {
         if (date.compareTo(DateUtils.SDF3.parse("2012-10-24 00:00:00")) == 0) {
            return true;
         }
      } catch (ParseException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      return false;
   }
   
   public static void main(String [] args){
      //System.out.println(clearTime(new Date()));
      
      //System.out.println(StringToDate(dateToString(new Date())));
      //System.out.println(date24ToString(new Date()));
      
      System.out.println(dateToString());
      
      try {
         System.out.println(DateUtils.SDF3.toPattern());
         
         System.out.println("getIsSaleBegin=="+getIsSaleBegin());

         System.out.println(DateUtils.dateToTimeMillis(new Date())> DateUtils.dateToTimeMillis(DateUtils.SDF3.parse("2012-08-1 23:59:59")));
      } catch (ParseException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }

   } 
   
   /**
    * 返回自定义格式的日期
    * @param date
    * @param format
    * @return
    */
   public static String getDateFormatstr(Date date, String format) {
      String rstr = "";
      try {
         SimpleDateFormat df = new SimpleDateFormat(format);
         rstr = df.format(date);
      } catch (Exception e) {
         return "";
      }
      return rstr;
   }

   /**
    * 获取当天日期
    * 
    * @return
    */
   public static String getTodayYYYYMMDD() {
      return getDateToyyyy_MM_dd(new Date());
   }

   /**
    * 返回yyyy-MM-dd:HH:mm:ss格式的日期
    * 
    * @param date
    * @return
    */
   public static String getDateToyyyy_MM_dd_HH_mm_ss(Date date) {
      return getDateFormatstr(date, "yyyy-MM-dd HH:mm:ss");
   }

   /**
    * 返回yyyyMMdd格式的日期
    * 
    * @param date
    * @return
    */
   public static String getDateToyyyyMMdd(Date date) {
      return getDateFormatstr(date, "yyyyMMdd");
   }

   /**
    * 返回yyyy-MM-dd格式的日期
    * 
    * @param date
    * @return
    */
   public static String getDateToyyyy_MM_dd(Date date) {
      return getDateFormatstr(date, "yyyy-MM-dd");
   }

   /**
    * 返回HH:mm:ss格式的时间
    * 
    * @param date
    * @return
    */
   public static String getDateToHH_mm_ss(Date date) {
      return getDateFormatstr(date, "HH:mm:ss");
   }

   /**
    * 返回HH:mm格式的时间
    * 
    * @param date
    * @return
    */
   public static String getDateToHH_mm(Date date) {
      return getDateFormatstr(date, "HH:mm");
   }

   /**
    * 返回HHmmss格式的时间
    * 
    * @param date
    * @return
    */
   public static String getDateToHHmmss(Date date) {
      return getDateFormatstr(date, "HHmmss");
   }

   /**
    * 根据yyyy-MM-dd HH:mm:ss返回日期类型
    * 
    * @param dateStr
    * @return Date 日期类型
    */
   public static Date getYYYY_MM_dd_HH_mm_ssToDate(String dateStr) {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      Date date = null;
      try {
         date = sdf.parse(dateStr);
      } catch (ParseException e) {
         e.printStackTrace();
      }
      return date;
   }
   public static String getYYYY_MM_dd_HH_mm_ssToYYYY_MM_dd(String dateStr) {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      Date date = null;
      try {
         date = sdf.parse(dateStr);
      } catch (ParseException e) {
         e.printStackTrace();
      }
      return getDateToyyyy_MM_dd(date);
   }

   /**
    * 日期互转 yyyy-MM-dd HH:mm:ss 转换为 HH:mm
    * 
    * @param dateStr
    * @return String HH:mm
    */
   public static String getDateStrToHH_mm(String dateStr) {
      Date date = getYYYY_MM_dd_HH_mm_ssToDate(dateStr);
      return getDateFormatstr(date, "HH:mm");
   }

   /**
    * 时长处理方法 传入开日期，和时长，转换为结束日期 如：传入2015-12-12 13:23:21 加上分钟转换为 2015-12-12
    * 14:23:21
    * 
    * @param 开始日期
    * @param 时长
    *            return 结束日期
    */
   public static Date getEndDate(Date startDate, int time) {
      Date endDate = new Date(startDate.getTime() + time * 60 * 1000);
      return endDate;
   }

   /**
    * 时长处理方法 传入开始日期，和时长，返回结束日期 如：传入2015-12-12 13:23:21 加上60分钟转换为 2015-12-12
    * 14:23:21
    * 
    * @param startDateStr
    *            开始日期字符串，格式：2015-12-12 13:23:21
    * @param time
    *            时长
    * @param return
    *            结束日期字符串
    */

   public static String getEndDateStr(String startDateStr, int time) {
      Date startDate = getYYYY_MM_dd_HH_mm_ssToDate(startDateStr);
      Date endDate = getEndDate(startDate, time);
      return getDateToyyyy_MM_dd_HH_mm_ss(endDate);
   }
   
   /**
    * 判断当前时间是否在区间内
    * @param startTime
    * @param endTime
    * @return
    */
   public static boolean between(Date startTime, Date endTime) {
      long currentTime = System.currentTimeMillis();
      if (currentTime > startTime.getTime() && currentTime < endTime.getTime()) {
         return true;
      }
      return false;
   }

   /**
    * 获取总耗时
    * 
    * @param start
    *            开时时间System.currentTimeMillis();
    * @return
    */
   public static long getTotalTime(long start) {
      return System.currentTimeMillis() - start;
   }

   /**
    * by yaoxing
    * 计算出离当前日期datas天的日期,若datas小于0表示当前日期之前datas天，若datas大于0表当前日期之后datas天
    * 参数传值参考：30（后推30天）,-30（后推30天）
    * 
    * @param 要计算的天数
    * @return 得到日期
    */
   public static Date getComputerDate(int datas) {
      GregorianCalendar calendar = new GregorianCalendar();
      calendar.add(GregorianCalendar.DATE, datas);
      String begin = new java.sql.Date(calendar.getTime().getTime()).toString();
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      Date beginDate = null;
      try {
         beginDate = sdf.parse(begin);
      } catch (ParseException e) {
         e.printStackTrace();
      }
      return beginDate;
   }
   
   /**
    * by yaoxing
    * 计算出离当前日期datas天的日期,若datas小于0表示当前日期之前datas天，若datas大于0表当前日期之后datas天
    * 参数传值参考：30（后推30天）,-30（后推30天）
    * 
    * @param 要计算的天数
    * @return 得到日期
    */
   public static Date getComputerDate(Date date,int datas) {
      GregorianCalendar calendar = new GregorianCalendar();
      calendar.add(GregorianCalendar.DATE, datas);
      String begin = new java.sql.Date(date.getTime()).toString();
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      Date beginDate = null;
      try {
         beginDate = sdf.parse(begin);
      } catch (ParseException e) {
         e.printStackTrace();
      }
      return beginDate;
   }
   
   /**
    * by yaoxing
    * 计算出离当前日期datas天的日期,若datas小于0表示当前日期之前datas天，若datas大于0表当前日期之后datas天
    * 参数传值参考：30（后推30天）,-30（后推30天）
    * 
    * @param 要计算的天数
    * @return 得到日期字符串，如20140728
    */
   public static String getComputeFormatDate(int datas) {
      Date date = getComputerDate(datas);
      String dateStr = getDateToyyyy_MM_dd(date);
      return dateStr + " 00:00:00";
   }

   /**
    * 获取当天的时间
    * 
    * @return
    */
   public static String getStartFormatToday() {
      return getTodayYYYYMMDD() + " 00:00:00";
   }

   /**
    * 获取当天的时间
    * 
    * @return
    */
   public static String getCurrentFromtDate() {
      return getDateToyyyy_MM_dd_HH_mm_ss(new Date());
   }
   
   /**
    * 获取当天的时间
    * 
    * @return
    */
   public static String getCurrentFromtDateTime() {
      return getDateToyyyyMMddHHmmss(new Date());
   }
   
   private static String getDateToyyyyMMddHHmmss(Date date) {
      return getDateFormatstr(date, "yyyyMMddHHmmss");
   }

   /**
    * 获取之前一天的最小时间
    * @return
    */
   public static String getTheDayBeforeMin() {
      return getDateBeforeMin(1);
   }
   
   /**
    * 获取7天前的最小时间
    * @return
    */
   public static String getSevenDateBeforeMin() {
      return getDateBeforeMin(7);
   }
   
   /**
    * 获取30天前的最小时间
    * @return
    */
   public static String getThirtyDateBeforeMin() {
      return getDateBeforeMin(30);
   }
   
   /**
    * 获取之前一天的最大时间
    * @return
    */
   public static String getTheDayBeforeMax() {
      return getDateBeforeMax(1);
   }
   
   /**
    * 获取7天前的最大时间
    * @return
    */
   public static String getSevenDateBeforeMax() {
      return getDateBeforeMax(7);
   }
   
   /**
    * 获取30天前的最大时间
    * @return
    */
   public static String getThirtyDateBeforeMax() {
      return getDateBeforeMax(30);
   }
   
   /**
    * 获取一天后的最小时间
    * @return
    */
   public static String getTheDayAfterMin() {
      return getDateAfterMin(1);
   }
   
   /**
    * 获取7天后的最小时间
    * @return
    */
   public static String getSevenDateAfterMin() {
      return getDateAfterMin(7);
   }
   
   /**
    * 获取30天后的最小时间
    * @return
    */
   public static String getThirtyDateAfterMin() {
      return getDateAfterMin(30);
   }
   
   /**
    * 获取一天后的最大时间
    * @return
    */
   public static String getTheDayAfterMax() {
      return getDateAfterMax(1);
   }
   
   /**
    * 获取7天后的最大时间
    * @return
    */
   public static String getSevenDateAfterMax() {
      return getDateAfterMax(7);
   }
   
   /**
    * 获取30天后的最大时间
    * @return
    */
   public static String getThirtyDateAfterMax() {
      return getDateAfterMax(30);
   }
   
   /**
    * 获取一个月后最大时间
    * @param date
    * @param i
    * @return
    * @throws ParseException
    */
   public static String getMonthDateAfterMax(String date, int i) throws ParseException {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      Date p1 = df.parse(date);
      Calendar cal = Calendar.getInstance();
      cal.setTime(p1);
      cal.add(Calendar.MONTH, i);
      return getDateToyyyy_MM_dd_HH_mm_ss(DateUtils.getTheDayMin(cal.getTime()));
   }
   
   /**
    * 获取一个月后的时间
    * @param date
    * @param i
    * @return
    * @throws ParseException
    */
   public static Date getMonthDateAfter(int i) throws ParseException {
      Date p1 = new Date();
      Calendar cal = Calendar.getInstance();
      cal.setTime(p1);
      cal.add(Calendar.MONTH, i);
      return cal.getTime();
   }
   
   /**
    * 获取一年后最大时间
    * @param date
    * @param i
    * @return
    * @throws ParseException
    */
   public static String getYearDateAfterMax(String date, int i) throws ParseException {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      Date p1 = df.parse(date);
      Calendar cal = Calendar.getInstance();
      cal.setTime(p1);
      cal.add(Calendar.YEAR, i);
      return getDateToyyyy_MM_dd_HH_mm_ss(DateUtils.getTheDayMax(cal.getTime()));
   }
   
   /**
    * 获取一年后最大时间
    * @param date
    * @param i
    * @return
    * @throws ParseException
    */
   public static Date getYearDateAfter(int i) throws ParseException {
      Date p1 = new Date();
      Calendar cal = Calendar.getInstance();
      cal.setTime(p1);
      cal.add(Calendar.YEAR, i);
      return cal.getTime();
   }
   
   /**
    * 获取指定天数前的最小日期
    * @param days
    * @return
    */
   public static String getDateBeforeMin(int days) {
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.DAY_OF_YEAR, -days);
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMin(cal.getTime())));
   }
   
   /**
    * 获取指定天数前的最大日期
    * @param days
    * @return
    */
   public static String getDateBeforeMax(int days) {
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.DAY_OF_YEAR, -days);
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMax(cal.getTime())));
   }
   
   /**
    * 获取指定天数后的最小日期
    * @param days
    * @return
    */
   public static String getDateAfterMin(int days) {
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.DAY_OF_YEAR, days);
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMin(cal.getTime())));
   }
   
   /**
    * 获取指定天数后的最大日期
    * @param days
    * @return
    */
   public static String getDateAfterMax(int days) {
      Calendar cal = Calendar.getInstance();
      cal.add(Calendar.DAY_OF_YEAR, days);
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMax(cal.getTime())));
   }
   
   /**
    * 获取本周第一天最小的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getWeekFirstDayMin() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); // 获取本周一的日期
      if (DateUtils.getTodayWeek() == 7) {
         cal.add(Calendar.WEEK_OF_YEAR, -1);
      }
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMin(cal.getTime())));
   }
   
   /**
    * 获取本周最后一天最大的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getWeekLastDayMax() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); // 获取本周日的日期
      if (DateUtils.getTodayWeek() != 7) {
         cal.add(Calendar.WEEK_OF_YEAR, 1);
      }
      return (getDateToyyyy_MM_dd_HH_mm_ss(getTheDayMax(cal.getTime())));
   }

   /**
    * 获取本周第一天的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getWeekFirstDay() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY); // 获取本周一的日期
      return (getDateToyyyy_MM_dd(cal.getTime()));
   }
   
   /**
    * 获取本周最后一天的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getWeekLastDay() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); // 获取本周日的日期
      cal.add(Calendar.WEEK_OF_YEAR, 1);
      return (getDateToyyyy_MM_dd(cal.getTime()));
   }

   /**
    * 获取本月第一天的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getMonFirstDay() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_MONTH, 1); // 获取本月第一天的日期
      return (getDateToyyyy_MM_dd(cal.getTime()));
   }

   /**
    * 获取本年第一天的日期
    * 
    * @return yyyy_MM_dd
    */
   public static String getYearFirstDay() {
      Calendar cal = Calendar.getInstance();
      cal.set(Calendar.DAY_OF_YEAR, 1); // 获取本年第一天的日期
      return (getDateToyyyy_MM_dd(cal.getTime()));
   }

   /**
    * 和当前时间进行比较
    * 
    * @param date1
    * @param date2
    * @return
    */
   public static boolean compareCurrentDate(Date date) {
      Date currentFromtDate = new Date();
      try {
         if (date.getTime() > currentFromtDate.getTime()) {
            return true;
         } else {
            return false;
         }
      } catch (Exception exception) {
         exception.printStackTrace();
      }
      return false;
   }
   
   /**
    * 和当前时间进行比较
    * 
    * @param date1
    * @param date2
    * @return
    */
   public static boolean compareCurrentDate(String date) {
      String currentFromtDate = getCurrentFromtDate();
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      try {
         Date dt1 = df.parse(date);
         Date dt2 = df.parse(currentFromtDate);
         if (dt1.getTime() > dt2.getTime()) {
            return true;
         } else {
            return false;
         }
      } catch (Exception exception) {
         exception.printStackTrace();
      }
      return false;
   }
   
   /**
    * 比较两个日期大小，date1大于date2,则返回true
    * 
    * @param date1
    * @param date2
    * @return
    */
   public static boolean compareDate(String date1, String date2) {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      try {
         Date dt1 = df.parse(date1);
         Date dt2 = df.parse(date2);
         if (dt1.getTime() > dt2.getTime()) {
            return true;
         } else {
            return false;
         }
      } catch (Exception exception) {
         exception.printStackTrace();
      }
      return false;
   }

   /**
    * 返回某个时间点多少天后的时间点
    * 
    * @param morningEndTime
    * @return yyyy-MM-dd hh:mm
    */
   public static String getDayNewTime(String time, int day) {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      try {
         Date dt1 = df.parse(time);
         long newTime = dt1.getTime() + 1000L*3600*24*day;
         Date newDate = new Date(newTime);
         return df.format(newDate);
      } catch (ParseException e) {
         e.printStackTrace();
      }
      return null;
   }
   
   public static String getAgeByBirthday(String birthDay) throws Exception{
      if (birthDay.length() == 10) {
         birthDay = birthDay + " 00:00:00";
      }
      int age = getAge(getYYYY_MM_dd_HH_mm_ssToDate(birthDay));
      if (age < 0) {
         age = 0;
      }
      return  age + "";
   }
   
   /**
    * 日期转换年龄
    * @param birthDay
    * @return
    * @throws Exception
    */
   public static int getAge(Date birthDay) throws Exception { 
        //获取当前系统时间
        Calendar cal = Calendar.getInstance(); 
        //如果出生日期大于当前时间，则抛出异常
        if (cal.before(birthDay)) { 
            throw new IllegalArgumentException( 
                "The birthDay is before Now.It's unbelievable!"); 
        } 
        //取出系统当前时间的年、月、日部分
        int yearNow = cal.get(Calendar.YEAR); 
        int monthNow = cal.get(Calendar.MONTH); 
        int dayOfMonthNow = cal.get(Calendar.DAY_OF_MONTH); 
         
        //将日期设置为出生日期
        cal.setTime(birthDay); 
        //取出出生日期的年、月、日部分  
        int yearBirth = cal.get(Calendar.YEAR); 
        int monthBirth = cal.get(Calendar.MONTH); 
        int dayOfMonthBirth = cal.get(Calendar.DAY_OF_MONTH); 
        //当前年份与出生年份相减，初步计算年龄
        int age = yearNow - yearBirth; 
        //当前月份与出生日期的月份相比，如果月份小于出生月份，则年龄上减1，表示不满多少周岁
        if (monthNow <= monthBirth) { 
            //如果月份相等，在比较日期，如果当前日，小于出生日，也减1，表示不满多少周岁
            if (monthNow == monthBirth) { 
                if (dayOfMonthNow < dayOfMonthBirth) age--; 
            }else{ 
                age--; 
            } 
        } 
        return age; 
    }
   
   /**
    * 判断时间是否在时间段内
    * @param start
    * @param end
    * @return
    */
   public static boolean isDateSectionByString(String start, String end) {  
      return isDateSection(getYYYY_MM_dd_HH_mm_ssToDate(start),getYYYY_MM_dd_HH_mm_ssToDate(end),new Date());
         
   }  

   /**
    * 判断时间是否在时间段内 
    * @param start
    * @param end
    * @param date
    * @return
    */
   public static boolean isDateSection(Date start, Date end, Date date) {  
       if (date.getTime() >= start.getTime() && date.getTime() <= end.getTime()) {  
           return true;  
       }  
       return false;  
   }  
   
   /**
    * 获取今天星期几
    * @return
    */
   public static int getTodayWeek(){
      Calendar now = Calendar.getInstance();
      //一周第一天是否为星期天
      boolean isFirstSunday = (now.getFirstDayOfWeek() == Calendar.SUNDAY);
      //获取周几
      int weekDay = now.get(Calendar.DAY_OF_WEEK);
      //若一周第一天为星期天，则-1
      if(isFirstSunday){
         weekDay = weekDay - 1;
          if(weekDay == 0){
             weekDay = 7;
         }
      }
      //打印周几
      return weekDay;
   }

   /**
    * 获取两个日期相减后的日期数
    * @param first_date
    * @param tow_date
    * @return
    * @throws ParseException
    */
   public static int getSubDate(String first_date, String tow_date) throws ParseException {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      Date f = df.parse(first_date);
      Date t = df.parse(tow_date);
      long time = f.getTime() - t.getTime();
      long d = time  / (1000 * 60 * 60 * 24) ;
      return (int) d;
   }
   
   public static int getSubSecond(String first_date, String tow_date) throws ParseException {
      DateFormat df = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
      Date f = df.parse(first_date);
      Date t = df.parse(tow_date);
      long time = f.getTime() - t.getTime();
      long d = time;
      return (int) d;
   }
}
5、异常类
public class APIException extends Exception {

   private static final long serialVersionUID = -1720859129158334517L;

   public APIException() {
      super();
   }
   
   public APIException(String msg){
      super(msg);
   }
   
   public APIException(String msg, Throwable cause){
      super(msg,cause);
   }
   
   public APIException(Throwable cause) {
      super(cause);
   }
}
public class ServiceException extends APIException {

   
   /**
    * serialVersionUID:TODO（用一句话描述这个变量表示什么）
    *
    * @since 1.0.0
    */
   
   private static final long serialVersionUID = -6006955331825052595L;

   /**
    * 创建一个新的实例 APIServiceException.
    *
    */

   public ServiceException() {
      // TODO Auto-generated constructor stub
   }

   /**
    * 创建一个新的实例 APIServiceException.
    *
    * @param msg
    */

   public ServiceException(String msg) {
      super(msg);
      // TODO Auto-generated constructor stub
   }

   /**
    * 创建一个新的实例 APIServiceException.
    *
    * @param msg
    * @param cause
    */

   public ServiceException(String msg, Throwable cause) {
      super(msg, cause);
      // TODO Auto-generated constructor stub
   }

   /**
    * 创建一个新的实例 APIServiceException.
    *
    * @param cause
    */

   public ServiceException(Throwable cause) {
      super(cause);
      // TODO Auto-generated constructor stub
   }

}
6、公共调用service
public class BaseService {
   /**
    * 读写
    */
   protected IMongoDAO mongoDao = MongoDAOFactory.getMongoDAO();
   /**
    * 只读
    */
   protected IMongoDAO mongoReadDao = MongoDAOFactory.getMongoReadDAO();
   /**
    * 只写
    */
   protected IMongoDAO mongoWriteDao = MongoDAOFactory.getMongoWriteDAO();
}
7、编写controller，测试
@Controller
@RequestMapping(value = "/first")
public class FirstController extends BaseService{

    private Logger logger =Logger.getLogger(String.valueOf(getClass()));
    private static final int pageSize =10;

   @RequestMapping(value = "/get",method = RequestMethod.GET)
   @ResponseBody
   public String get(HttpServletRequest request){
       //接下来这些参数类似于京东淘宝购物页面，有多个筛选条件，交个区间，价格等等。。

       int page = ServletRequestUtils.getIntParameter(request,"page",0);
       String roleName =ServletRequestUtils.getStringParameter(request,"roleName",null);
       //solrName 在一个搜索框中同时可以搜索昵称、手机、邮箱、账号，所以这个代码用到JSONArray
       String solrName =ServletRequestUtils.getStringParameter(request,"roleName",null);
       String startTime =ServletRequestUtils.getStringParameter(request,"startTime",null);
       String endTime =ServletRequestUtils.getStringParameter(request,"endTime",null);
       logger.debug("roleName"+roleName);
       logger.debug("solrName"+solrName);
       logger.debug("startTime"+startTime);
       logger.debug("endTime"+endTime);
       //query为查询条件
       DBObject query =new BasicDBObject();

       JSONObject jsonObject = new JSONObject();
       jsonObject.put("$ne","超级管理员");
       query.put("name",jsonObject);

       //搜索文本中可以搜索的四个字段的查询代码
       if (solrName !=null && !solrName.isEmpty()){
           //搜索框中搜索昵称
           JSONObject nickJson = new JSONObject();
           DBObject nickDB =new BasicDBObject();
           nickJson.put("$regex",solrName.trim());
           nickDB.put("nickName",nickJson);
           //搜索框中为手机，这个利用克隆
           DBObject mobileDB =new BasicDBObject();
           mobileDB.put("mobile",nickJson.clone());
           //搜索框中为邮箱
           DBObject emailDB =new BasicDBObject("email",nickJson.clone());
           //搜索框中为账号
           DBObject accountDB =new BasicDBObject("account",nickJson.clone());
           JSONArray $or =new JSONArray();
           $or.add(nickDB);
           $or.add(mobileDB);
           $or.add(accountDB);
           $or.add(emailDB);
           query.put("$or",$or);
       }
        //时间区域内的查询代码,如果是价格区间代码类似
       if (!StringUtils.isEmpty(startTime) || !StringUtils.isEmpty(endTime)){
            JSONObject timeJson =new JSONObject();
            timeJson.put("$gte",startTime);
            timeJson.put("$lte",endTime);
            query.put("createAt",timeJson);
       }
       //查询返回的字段，{} == 意思是返回集合中所有字段
       String fields ="{}";

       JSONObject orderby =new JSONObject();
       orderby.put("createdAt",-1);//在monggodb中，-1降序，1升序

       //t_role 为mongodb 的一个集合 相当于MySQL中的一个表
       DBObject dbObject1 = mongoReadDao.find(query.toString(), fields, orderby.toJSONString(), "t_role",page*pageSize,pageSize);

       List<JSONObject> lists = null;
       if (dbObject1 != null && (int)dbObject1.get("count")>0){
           lists = new ArrayList<JSONObject>();
           BasicDBList results =(BasicDBList) dbObject1.get("results");
           JSONObject obj = null;
           for (Object item : results){
               obj = JSONObject.parseObject(item.toString());
               lists.add(obj);
           }
       }
       //下面是分页
       int counts =Integer.parseInt(dbObject1.get("count").toString());
       int totalPage = 0;
       if(counts<=pageSize){
           totalPage = 1;
       }else{
           totalPage = counts/pageSize;
           if(totalPage*pageSize<counts){
               totalPage+=1;
           }
       }

       JSONObject resultObj = new JSONObject();
       resultObj.put("list", lists);
       resultObj.put("currentPage", page);
       resultObj.put("counts", counts);
       resultObj.put("totalPage", totalPage);

       return resultObj.toJSONString();
   }

   @RequestMapping(value = "/insert",method = RequestMethod.POST)
   @ResponseBody
    public String add(HttpServletRequest request) throws Exception{
       String account =ServletRequestUtils.getStringParameter(request,"account",null);
       String email =ServletRequestUtils.getStringParameter(request,"email",null);
       String mobile =ServletRequestUtils.getStringParameter(request,"mobile",null);
       Date date =new Date();
       SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
       String createAt =simpleDateFormat.format(date);

       logger.debug("account==>"+account);
       logger.debug("email==>"+email);
       logger.debug("mobile==>"+mobile);

       JSONObject jsonObject =new JSONObject();
       jsonObject.put("account",account);
       jsonObject.put("email",email);
       jsonObject.put("mobile",mobile);
       JSONObject result =mongoWriteDao.save("t_admin",jsonObject.toJSONString());
       return result.toJSONString();
   }

    @RequestMapping(value = "/update",method = RequestMethod.POST)
    @ResponseBody
    public String update(HttpServletRequest request)throws Exception{
       String email =ServletRequestUtils.getStringParameter(request,"email","152@qq.com");
       String id = ServletRequestUtils.getStringParameter(request,"id","5a24b0bae6ebae2a742eeacb");
       logger.debug("email==>"+email);
       JSONObject jsonObject =new JSONObject();
       jsonObject.put("email",email);
       JSONObject result =mongoWriteDao.update("t_admin",jsonObject.toJSONString(),id);
       return result.toJSONString();
    }
}

7834e9416765b5b42e06dd7453bb209885a.jpg

4eef27fb6ac91d3b16d8d58c173c6b0e2fa.jpg

成功！

转载于:https://my.oschina.net/mdxlcj/blog/1859527

weixin_33698043
关注
使用springboot实现读写分离+项目实战
qq_37037991的博客
03-27 5505
使用springboot实现读写分离这也是闲着无聊然后去了解了一下然后写了一个项目,如有不足，欢迎来指出来功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLow...
在SpringBoot下用java操作MongoDB数据库的增删改查
zekeTao的博客
02-27 5612
首先我们需要建立一个SpringBoot工程，在IDEA中有快捷的创建方式。   new -&gt; project -&gt; Spring Initializr 根据需要一路next下去即可     第二步，给application.properties添加MongoDB配置   #MongoDB #spring.data.mongodb.username=root #sp...
Spring Boot MongoDB 可复制集的读写分离
weixin_30608131的博客
07-05 864
最近项目的一个版本刚迭代上去，然后设备也陆续地接入到了系统中。 设备产生的数据经过解析、处理之后落到了 MongoDB 中，但是才 10w 的数据就导致分页查询非常慢，count 操作也是慢的感人。 上午加了索引之后，从 10 多秒降到了 5 秒左右，但是这个速度还是很慢啊，这 TM 的等到设备都接入进来不就炸了。 然后下午就开始排错，查看代码中的慢查询。 最后发现一个现象就是：通过...
SpringBoot项目开发(二十二)：SpringBoot MongoDB实现副本集(读写分离)
热门推荐
zhuyu19911016520
10-10 1万+
1.MongoDB可以单库、主从(官方现已不推荐)、副本集、分片加副本集，通过分片加副本集可以组成庞大的数据存储集群，而大部分项目使用副本集就能满足需求了 2.MongoDB副本集（Replica Set）：有自动故障恢复功能的主从集群，有一个Primary节点和一个或多个Secondary节点组成。 3.副本集环境搭建，请参考 Mongodb安装与设置副本集 4.SpringBoot实现 Mon...
spring boot mongo (复本集群)读写分离
面朝大海，春暖花开
03-20 1481
spring boot mongo (复本集群)读写分离 引入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> application.yml配置文件 spring: data: mo
Springboot 集成 MongoDB （使用事务 | 读写分离）
weixin_40863968的博客
08-31 1777
springboot 集成 mongodb （使用事务 | 读写分离）
Java springboot Mongodb增删改查代码实例
08-18
Java SpringBoot MongoDB 增删改查代码实例 本文将详细介绍 Java SpringBoot MongoDB 增删改查代码实例，包括添加依赖、配置 MongoDB、实现增删改查操作等内容。 添加依赖 为了使用 MongoDB，在 SpringBoot 项目...
SpringBoot 2.x + Mongodb配置SSL
yanruqian的博客
12-24 2111
SpringBoot 2.x + Mongodb配置SSL
Node.js中实现MongoDB数据库的增删改查
SongD1114的博客
04-11 2355
Node.js中使用MongoDB数据库
SpringCloud集成mongodb实现增删改查、分页、排序、聚合操作
12程序猿的博客
05-10 2338
一、前言 MongoDB是⼀个开源、⾼性能、⽆模式的⽂档型数据库，当初的设计就是⽤于简化开发和⽅便扩展，是NoSQL数据库产品中的⼀种。是最像关系型数据库（MySQL）的⾮关系型数据库。 它⽀持的数据结构⾮常松散，是⼀种类似于 JSON 的 格式叫BSON，所以它既可以存储⽐较复杂的数据类型，⼜相当的灵活。 二、集成实现 1.添加pom依赖 <!--mangodb核心包--> <dependency> <groupId>org.springframework.bo
Spring boot实现数据库读写分离的方法
08-31
本篇文章主要介绍了Spring boot实现数据库读写分离的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot + MonggoDB副本集windows下集群读写分离搭建--进阶篇
Dcj695632854的博客
03-10 267
接：基础篇 新增两个节点，模拟Mongodb集群选举 1.新增Mongodb服务，配置接上篇 2.开启服务 3.登录任意一台服务 4.新增集群节点 rs.add( { host: "127.0.0.1:27020", priority: 0, votes: 0 } ) rs.add( { host: "127.0.0.1:27021", priority: 0, votes: 0 } ) 5.查看状态 rs.status() { "set" : "rs0",
SpringBoot + MonggoDB副本集windows下集群读写分离搭建
Dcj695632854的博客
03-09 636
一、windows下的MongoDB集群搭建 1.安装Mongodb 2.创建Mongodb表及日志文件地址： G:\MongoDB3.6.21\data1\db G:\MongoDB3.6.21\data1\log G:\MongoDB3.6.21\data2\db G:\MongoDB3.6.21\data2\log G:\MongoDB3.6.21\data3\db G:\MongoDB3.6.21\data3\log 3.创建Mongodb配置文件 G:\MongoDB3.6.21\mon
springboot配置读写分离
weixin_33698043的博客
10-16 128
2019独角兽企业重金招聘Python工程师标准>>> ...
MongoDB基础知识（Docker安装MongoDB集群并与SpringBoot整合 实现高可用 读写分离等）
weixin_40760239的博客
03-15 494
MongoDB笔记 mac可视化工具：Studio 3T for MongoDB win:robo3T docker安装mongo 拉镜像 docker pull mongo 启动 docker run -p 8002:27017 -v /mydocker/mongo/db:/data/db --name mongodb -d mongo 登录 docker exec -it 421b2c37b270 /bin/bash mongo或者mongo 127.0.0.1:27017/库名 -u admi
springboot配置php,springboot中怎么配置读写分离
weixin_29173777的博客
04-05 359
springboot中配置读写分离的方法：首先配置“spring.data.mongodb.uri”；然后创建一个Rest风格的“IndexController”；最后验证读写分离是否生效即可。mongoDB的读写分离一、ReadPreference读偏好在副本集Replica Set中才涉及到ReadPreference的设置，默认情况下，读写都是分发都Primary节点执行，但是对于写少读多的...
mongodb 读写分离
yisun123456的博客
11-28 773
mongoDB官方已经不建议使用主从模式了，替代方案是采用副本集的模式， 点击查看。如果您的环境不符合副本集模式可参考本文，来实现主从读写分离。  resources.properties mongodb_read.host=10.0.0.45 mongodb_read.port=27017 mongodb_read.apname=ecsp mongodb_read.username= mon
MongoDB入门学习之Springboot整合Mongo并操作Mongo
weixin_42939612的博客
12-04 569
最近在熟悉公司业务代码的时候发现使用到了MongoDB，好奇实际工程中底层是如何进行封装数据访问层的，特此学习记录一下 Spring对MongoDB的操作进行了类似于JDBCTemplate的封装，集成以后可以使用MongoOperations达成我们想要的操作，或在此基础上进一步封装 ps:本工程是使用注解方式配置 #mongo配置 mongo: host: 10.10.21.52:27...
MongoDB副本集搭建和读写分离配置
最新发布
千月落
01-12 1961
MongoDB副本集（Replication Set）由一组mongod实例(进程)组成，包含一个Primary节点和多个Secondary节点.客户端数据写入Primary节点。Secondary节点从Primary节点同步数据。以保持副本集内所有成员存储相同的数据集。Primary节点故障时会自动选举出一个新的Primary节点。：将数据从一个区域复制到另一个区域，减少另一个区域的读延迟。：不同类型的压力分别在不同节点上执行。：在数据中心故障时快速切换到异地。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值