崛起于Springboot2.X之集成读写分离MongoDB使用Client增删改查(25)
转载请注明出处！使用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","[email protected]");
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();
}
}
成功！
转载于:https://my.oschina.net/mdxlcj/blog/1859527