init

META-INF/MANIFEST.MF

@@ -0,0 +1,2 @@
+Manifest-Version: 1.0
+

pom.xml

@@ -0,0 +1,193 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<groupId>com.dashitech</groupId>
+	<artifactId>HSMSV1-DataMigration</artifactId>
+	<version>1.0.0</version>
+	<packaging>jar</packaging>
+
+	<name>HSMSV1-DataMigration</name>
+
+	<parent>
+		<groupId>org.springframework.boot</groupId>
+		<artifactId>spring-boot-starter-parent</artifactId>
+		<version>1.5.8.RELEASE</version>
+		<relativePath />
+	</parent>
+<!--	<artifactId>spring-boot-starter-logging</artifactId>
+	<name>Spring Boot Logging Starter</name>
+	<description>Starter for logging using Logback. Default logging starter</description>
+	<url>http://projects.spring.io/spring-boot/</url>-->
+	<properties>
+		<tomcat.version>7.0.59</tomcat.version>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<java.version>1.8</java.version>
+	</properties>
+
+	<dependencies>
+
+
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-test</artifactId>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-web</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-aop</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-devtools</artifactId>
+			<optional>true</optional>
+		</dependency>
+
+		<dependency>
+			<groupId>org.apache.commons</groupId>
+			<artifactId>commons-lang3</artifactId>
+			<version>3.3.2</version>
+		</dependency>
+
+		<dependency>
+			<groupId>net.sf.json-lib</groupId>
+			<artifactId>json-lib</artifactId>
+			<version>2.4</version>
+			<classifier>jdk15</classifier>
+		</dependency>
+
+		<dependency>
+			<groupId>commons-httpclient</groupId>
+			<artifactId>commons-httpclient</artifactId>
+			<version>3.0.1</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.apache.httpcomponents</groupId>
+			<artifactId>httpmime</artifactId>
+			<version>4.3.4</version>
+		</dependency>
+
+
+		<dependency>
+			<groupId>org.springframework</groupId>
+			<artifactId>spring-context-support</artifactId>
+			<version>4.2.4.RELEASE</version>
+		</dependency>
+
+
+
+		<!-- db -->
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-starter-data-jpa</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>javax.transaction</groupId>
+					<artifactId>javax.transaction-api</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+
+		<dependency>
+			<groupId>org.jboss.spec.javax.transaction</groupId>
+			<artifactId>jboss-transaction-api_1.2_spec</artifactId>
+			<version>1.0.0.Final</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.hibernate</groupId>
+			<artifactId>hibernate-entitymanager</artifactId>
+		</dependency>
+
+		<dependency>
+			<groupId>com.alibaba</groupId>
+			<artifactId>druid</artifactId>
+			<version>1.0.18</version>
+		</dependency>
+
+		<dependency>
+			<groupId>com.alibaba</groupId>
+			<artifactId>fastjson</artifactId>
+			<version>1.2.83</version>
+		</dependency>
+
+		<dependency>
+			<groupId>mysql</groupId>
+			<artifactId>mysql-connector-java</artifactId>
+			<version>5.1.34</version>
+		</dependency>
+		<dependency>
+			<groupId>com.microsoft.sqlserver</groupId>
+			<artifactId>sqljdbc4</artifactId>
+			<version>4.0</version>
+		</dependency>
+		<dependency>
+			<groupId>redis.clients</groupId>
+			<artifactId>jedis</artifactId>
+			<version>2.9.0</version>
+		</dependency>
+		<dependency>
+			<groupId>org.atmosphere</groupId>
+			<artifactId>atmosphere-runtime</artifactId>
+			<version>2.4.28</version>
+		</dependency>
+		<dependency>
+			<groupId>org.jboss.netty</groupId>
+			<artifactId>netty</artifactId>
+			<version>3.2.5.Final</version>
+		</dependency>
+		<dependency>
+			<groupId>com.belerweb</groupId>
+			<artifactId>pinyin4j</artifactId>
+			<version>2.5.0</version>
+		</dependency>
+		<dependency>
+			<groupId>com.oracle.database.jdbc</groupId>
+			<artifactId>ojdbc8</artifactId>
+			<version>12.2.0.1</version>
+		</dependency>
+
+
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-autoconfigure</artifactId>
+			<scope>compile</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.springframework.boot</groupId>
+			<artifactId>spring-boot-configuration-processor</artifactId>
+			<scope>compile</scope>
+		</dependency>
+	</dependencies>
+	<build>
+
+		<plugins>
+			<plugin>
+				<groupId>org.springframework.boot</groupId>
+				<artifactId>spring-boot-maven-plugin</artifactId>
+				<executions>
+					<execution>
+						<goals>
+							<goal>repackage</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+    <repositories>
+        <repository>
+            <id>clojars</id>
+            <url>http://clojars.org/repo/</url>
+        </repository>
+    </repositories>
+</project>

src/main/java/com/dashitech/Application.java

@@ -0,0 +1,34 @@
+package com.dashitech;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.ImportResource;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+
+
+@SpringBootApplication
+@EnableAsync
+@EnableScheduling
+@ComponentScan(basePackages = {"com.dashitech"})
+@PropertySource({"classpath:application-custom.properties", "application.properties"})
+@ImportResource(locations = "classpath*:/application-context.xml")
+//@Import({DynamicDataSourceRegister.class}) // 注册动态多数据源
+//@MapperScan("com.dashitech.dao.mysqldb1")//将项目中对应的mapper类的路径加进来就可以了
+//@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class, HibernateJpaAutoConfiguration.class})    //不连数据库
+public class Application {
+
+    public static void main(String[] args) {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        System.out.println("hsmsV1>>>>>>>>>>>>>>>>>>startData" + sdf.format(new Date()));
+        SpringApplication.run(Application.class, args);
+    }
+
+
+}

src/main/java/com/dashitech/api/rest/ApiRest.java

@@ -0,0 +1,28 @@
+package com.dashitech.api.rest;
+
+import com.dashitech.migration.StartApplication;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.RestController;
+
+@RestController
+@RequestMapping(value = "/api")
+public class ApiRest {
+
+    @Autowired
+    StartApplication startApplication;
+
+
+    @RequestMapping(value = "/start", method = RequestMethod.GET)
+    @ResponseBody
+    public String start() {
+
+        startApplication.start();
+
+        return "ok";
+    }
+
+
+}

src/main/java/com/dashitech/bean/BaseBean.java

@@ -0,0 +1,43 @@
+package com.dashitech.bean;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * Created by chi on 2019/9/9.
+ */
+public class BaseBean implements Serializable {
+    /**
+     * bean类型
+     */
+    private String beanType;
+
+    /**
+     *对象数组
+    */
+    private List<Object> objectList;
+
+    public String getBeanType() {
+        return beanType;
+    }
+
+    public void setBeanType(String beanType) {
+        this.beanType = beanType;
+    }
+
+    public List<Object> getObjectList() {
+        return objectList;
+    }
+
+    public void setObjectList(List<Object> objectList) {
+        this.objectList = objectList;
+    }
+
+    @Override
+    public String toString() {
+        return "BaseBean{" +
+                "beanType='" + beanType + '\'' +
+                ", objectList=" + objectList +
+                '}';
+    }
+}

src/main/java/com/dashitech/bean/ResultMsg.java

@@ -0,0 +1,73 @@
+package com.dashitech.bean;
+
+//import com.dashitech.jsondata.entity.*;
+
+import javax.xml.bind.annotation.XmlSeeAlso;
+import java.io.Serializable;
+
+/**
+ * Created by chi on 2019/9/10.
+ */
+
+//@XmlSeeAlso({CallOnJSONEntity.class, PatientJSONEntity.class, DrugsBagJSONEntity.class, InspectJSONEntity.class, JPDetailsJSONEntity.class,DrugsJSONEntity.class,JPBagJSONEntity.class,SpecimenJSONEntity.class,BarthleJSONEntity.class,BuildingJSONEntity.class,DepartmentJSONEntity.class
+//,FloorJSONEntity.class,UserJSONEntity.class})
+public class ResultMsg implements Serializable {
+
+    /**
+     * 调用是否成功唯一标识
+     */
+    private Boolean success;
+    /**
+     * 描述
+     */
+    private String msg;
+
+    private int successCount;
+
+    private int failCount;
+
+    private String failReason;
+
+    public Boolean getSuccess() {
+        return success;
+    }
+
+    public void setSuccess(Boolean success) {
+        this.success = success;
+    }
+
+    public String getMsg() {
+        return msg;
+    }
+
+    public void setMsg(String msg) {
+        this.msg = msg;
+    }
+
+    public int getSuccessCount() {
+        return successCount;
+    }
+
+    public void setSuccessCount(int successCount) {
+        this.successCount = successCount;
+    }
+
+    public int getFailCount() {
+        return failCount;
+    }
+
+    public void setFailCount(int failCount) {
+        this.failCount = failCount;
+    }
+
+    @Override
+    public String toString() {
+        return "ResultMsg{" +
+                "success=" + success +
+                ", msg='" + msg + '\'' +
+                ", successCount=" + successCount +
+                ", failCount=" + failCount +
+                ", failReason='" + failReason + '\'' +
+                '}';
+    }
+}

src/main/java/com/dashitech/config/ApiFilterConfig.java

@@ -0,0 +1,58 @@
+package com.dashitech.config;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.web.servlet.ModelAndView;
+import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+/**
+ * API-rest服务拦截器 <br/>
+ * 对请求进行ip校验,出错返回拒绝信息
+ */
+public class ApiFilterConfig extends HandlerInterceptorAdapter {
+    private static Log log = LogFactory.getLog(ApiFilterConfig.class);
+
+    @Override
+    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
+        super.postHandle(request, response, handler, modelAndView);
+    }
+
+    @Override
+    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
+        super.afterCompletion(request, response, handler, ex);
+    }
+
+    @Override
+    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
+        response.setCharacterEncoding("UTF-8");
+
+//        HandlerMethod hm = (HandlerMethod) handler;
+//        String visitMethod = hm.getMethod().getName();
+
+        //校验
+        boolean flag = check(request.getRemoteHost());
+
+        //验证失败，拒绝请求
+  /*      if (!flag) {
+            MessageResult result = new MessageResult();
+            result.setSuccess(false);
+            result.setMsg("403 forbidden");
+            response.getWriter().print(JsonUtil.toJsonString(result));
+        }else {
+            log.error("ApiFilter Check Error："+ request.getRequestURL().toString() + "  IP："+ request.getRemoteAddr());
+        }*/
+
+        return flag;
+    }
+
+    private boolean check(String ip) {
+//        if (StringUtils.isNotEmpty(ip) && (ip.equals("127.0.0.1") || ip.equals("localhost") || ip.equals("0:0:0:0:0:0:0:1"))) {
+//            return true;
+//        }
+//        return false;
+        return true;
+    }
+}

src/main/java/com/dashitech/config/ApiWeblogFilterConfig.java

@@ -0,0 +1,48 @@
+package com.dashitech.config;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.AfterReturning;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.annotation.Before;
+import org.aspectj.lang.annotation.Pointcut;
+import org.springframework.core.annotation.Order;
+import org.springframework.stereotype.Component;
+import org.springframework.web.context.request.RequestContextHolder;
+import org.springframework.web.context.request.ServletRequestAttributes;
+
+import javax.servlet.http.HttpServletRequest;
+
+/**
+ * 路径拦截器
+ */
+@Aspect
+@Order(2)
+@Component
+public class ApiWeblogFilterConfig {
+    private static Log log = LogFactory.getLog(ApiWeblogFilterConfig.class);
+
+    ThreadLocal<Long> startTime = new ThreadLocal<Long>();
+
+    @Pointcut("execution(public * com.dashitech.api..*.*(..))")
+    public void webLog() {
+        log.info("show()");
+    }
+
+    @Before("webLog()")
+    public void doBefore(JoinPoint joinPoint) throws Throwable {
+        startTime.set(System.currentTimeMillis());
+        // 接收到请求，记录请求内容
+        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
+        HttpServletRequest request = attributes.getRequest();
+        // 记录下请求内容
+        log.info(Thread.currentThread().getName() + "   ApiLog-URL : " + request.getRequestURL().toString() + "   IP : " + request.getRemoteAddr());
+//        log.info(Thread.currentThread().getName() + "   ApiLog-ARGS : " + Arrays.toString(joinPoint.getArgs()));
+    }
+
+    @AfterReturning(returning = "ret", pointcut = "webLog()")
+    public void doAfterReturning(Object ret) throws Throwable {
+        log.info(Thread.currentThread().getName() + "   ApiLog-AVG/MS : " + (System.currentTimeMillis() - startTime.get()) + "/ms ");
+    }
+}

src/main/java/com/dashitech/config/DataSourceConfig.java

@@ -0,0 +1,45 @@
+
+package com.dashitech.config;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+
+import javax.sql.DataSource;
+
+
+/**
+ * Created by chi on 2019/9/20.
+ */
+
+@Configuration
+public class DataSourceConfig {
+
+    /**
+     *  数据源2
+     */
+    @Primary
+    @Bean(name = "mysql2DataSource")
+    @Qualifier(value = "mysql2DataSource")
+    @ConfigurationProperties(prefix = "mysql2.spring.datasource")
+    public DataSource mysql2DataSource(){
+        return DataSourceBuilder.create().build();
+    }
+
+
+    /**
+     *  数据源3
+     */
+
+    @Bean(name = "mysql3DataSource")
+    @Qualifier(value = "mysql3DataSource")
+    @ConfigurationProperties(prefix = "mysql3.spring.datasource")
+    public DataSource mysql3DataSource(){
+        return DataSourceBuilder.create().build();
+    }
+
+}
+

src/main/java/com/dashitech/config/DruidConfig.java

@@ -0,0 +1,16 @@
+package com.dashitech.config;
+
+import javax.servlet.annotation.WebInitParam;
+import javax.servlet.annotation.WebServlet;
+
+@WebServlet(urlPatterns = "/druid/*", 
+    initParams={
+            @WebInitParam(name="allow",value="127.0.0.1"),// IP白名单 (没有配置或者为空，则允许所有访问)
+            @WebInitParam(name="deny",value="192.168.16.111"),// IP黑名单 (存在共同时，deny优先于allow)
+            @WebInitParam(name="loginUsername",value="itsm"),// 用户名
+            @WebInitParam(name="loginPassword",value="100100"),// 密码
+            @WebInitParam(name="resetEnable",value="false")// 禁用HTML页面上的“Reset All”功能
+    })
+public class DruidConfig {
+
+}

src/main/java/com/dashitech/config/DruidFilter.java

@@ -0,0 +1,14 @@
+package com.dashitech.config;
+
+import com.alibaba.druid.support.http.WebStatFilter;
+
+import javax.servlet.annotation.WebFilter;
+import javax.servlet.annotation.WebInitParam;
+
+@WebFilter(filterName="druidWebStatFilter",urlPatterns="/*",
+	    initParams={
+	        @WebInitParam(name="exclusions",value="*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")// 忽略资源
+	})
+public class DruidFilter extends WebStatFilter{
+
+}

src/main/java/com/dashitech/config/JdbcTemplateConfig.java

@@ -0,0 +1,22 @@
+package com.dashitech.config;
+
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Primary;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.sql.DataSource;
+
+@Configuration
+public class JdbcTemplateConfig {
+    @Bean
+    @Primary
+    public JdbcTemplate jdbcTemplateHsms(@Qualifier("mysql2DataSource")DataSource dataSource){
+        return new JdbcTemplate(dataSource);
+    }
+    @Bean
+    public JdbcTemplate jdbcTemplateMdv2(@Qualifier("mysql3DataSource")DataSource dataSource){
+        return new JdbcTemplate(dataSource);
+    }
+}

src/main/java/com/dashitech/config/ScheduleConfig.java

@@ -0,0 +1,17 @@
+package com.dashitech.config;
+
+import org.springframework.beans.factory.annotation.Configurable;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.SchedulingTaskExecutor;
+import org.springframework.scheduling.annotation.SchedulingConfigurer;
+import org.springframework.scheduling.config.ScheduledTaskRegistrar;
+
+import java.util.concurrent.Executors;
+
+@Configuration
+public class ScheduleConfig implements SchedulingConfigurer {
+    @Override
+    public void configureTasks(ScheduledTaskRegistrar taskRegistrar){
+        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(15));
+    }
+}

src/main/java/com/dashitech/config/SessionFactoryConfig.java

@@ -0,0 +1,36 @@
+/*
+package com.dashitech.config;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.orm.hibernate4.LocalSessionFactoryBean;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+
+import javax.sql.DataSource;
+import java.util.Properties;
+
+@Configuration
+@EnableTransactionManagement
+public class SessionFactoryConfig {
+	
+	@Autowired
+	DataSource dataSource;
+	
+	@Bean
+	public LocalSessionFactoryBean sessionFactory() {
+		LocalSessionFactoryBean sessionFactoryBean = new LocalSessionFactoryBean();
+		sessionFactoryBean.setDataSource(dataSource);
+		Properties properties1 = new Properties();
+		properties1.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5Dialect");
+		properties1.setProperty("hibernate.show_sql", "false");
+		sessionFactoryBean.setHibernateProperties(properties1);
+		sessionFactoryBean.setPackagesToScan("com.dashitech.entity.mysqldatabase1");
+		
+		return sessionFactoryBean;
+	}
+	
+	
+}
+
+*/

src/main/java/com/dashitech/config/TomcatConfig.java

@@ -0,0 +1,30 @@
+package com.dashitech.config;
+
+import org.apache.catalina.connector.Connector;
+import org.apache.coyote.http11.Http11NioProtocol;
+import org.springframework.boot.context.embedded.EmbeddedServletContainer;
+//import org.springframework.boot.context.embedded.ServletContextInitializer;
+import org.springframework.boot.web.servlet.ServletContextInitializer;
+import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
+import org.springframework.stereotype.Component;
+
+import java.nio.charset.Charset;
+
+@Component
+public class TomcatConfig extends TomcatEmbeddedServletContainerFactory {
+	public EmbeddedServletContainer getEmbeddedServletContainer(ServletContextInitializer... initializers) {
+		return super.getEmbeddedServletContainer(initializers);
+	}
+
+	protected void customizeConnector(Connector connector) {
+		super.customizeConnector(connector);
+		setUriEncoding(Charset.forName("UTF-8"));
+		Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
+		// 设置最大连接数
+		protocol.setMaxConnections(1000);
+		// 设置最大线程数
+		protocol.setMaxThreads(1000);
+		protocol.setConnectionTimeout(30000);
+	}
+
+}

src/main/java/com/dashitech/config/WebServiceConfig.java

@@ -0,0 +1,32 @@
+package com.dashitech.config;
+
+
+/**
+ * Created by chi on 2019/9/16.
+ */
+/*@Configuration
+public class WebServiceConfig {
+
+    @Autowired
+    private ApiWebService apiWebService;
+
+
+    @Bean
+    public ServletRegistrationBean disServlet() {
+        return new ServletRegistrationBean(new CXFServlet(),"/web/*");
+    }
+
+    @Bean(name = Bus.DEFAULT_BUS_ID)
+    public SpringBus springBus() {
+        return new SpringBus();
+    }
+
+    @Bean
+    public Endpoint endpoint() {
+        EndpointImpl endpoint = new EndpointImpl(springBus(), apiWebService);
+        endpoint.publish("/service");
+        return endpoint;
+    }
+
+
+}*/

src/main/java/com/dashitech/migration/BaseTask.java

@@ -0,0 +1,26 @@
+package com.dashitech.migration;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ * Created by CX on 2024/10/10.
+ */
+public abstract class BaseTask implements SqlTask {
+
+    protected Map cache = new LinkedHashMap();
+
+    @Autowired
+    @Qualifier("jdbcTemplateHsms")
+    protected JdbcTemplate jdbcTemplateHsms;
+
+    @Autowired
+    @Qualifier("jdbcTemplateMdv2")
+    protected JdbcTemplate jdbcTemplateMdv2;
+
+
+}

src/main/java/com/dashitech/migration/SqlTask.java

@@ -0,0 +1,19 @@
+package com.dashitech.migration;
+
+import com.dashitech.migration.core.FieldMapper;
+
+/**
+ * Created by CX on 2024/10/10.
+ */
+public interface SqlTask {
+
+    /**
+     * 不需要try/catch，有错就抛出来处理
+     */
+    FieldMapper start(FieldMapper fieldMapper);
+
+    /**
+     * 如果之前执行有报错，需要重新加载特定字段缓存数据
+     */
+    FieldMapper loadCache();
+}

src/main/java/com/dashitech/migration/StartApplication.java

@@ -0,0 +1,30 @@
+package com.dashitech.migration;
+
+import com.dashitech.migration.core.FieldMapper;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+/**
+ * 迁移数据启动类
+ * Created by CX on 2024/10/10.
+ */
+@Service
+public class StartApplication {
+
+    public static Log log = LogFactory.getLog(StartApplication.class);
+
+    @Autowired
+    SqlTask groupTask;
+
+    public void start() {
+        //工作组
+        FieldMapper groupMapper = groupTask.start(null);
+//        FieldMapper groupMapper = groupTask.loadCache();
+        System.out.println(groupMapper);
+
+    }
+
+
+}

src/main/java/com/dashitech/migration/core/DataMapper.java

@@ -0,0 +1,123 @@
+package com.dashitech.migration.core;
+
+import java.io.Serializable;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * 数据匹配器
+ */
+public class DataMapper implements Serializable{
+
+    private String targetName;
+    private Object targetValue;
+    private Long targetId;
+    private String sourceName;
+    private Object sourceValue;
+    private Long sourceId;
+    private boolean remove = false;
+    private boolean update = false;
+    private boolean add = false;
+    private boolean replace = false;
+    /**
+     * 匹配完成后的id对照，source:target
+     */
+    private Map<Long, Long> idCache = new HashMap<>();
+
+    public DataMapper() {
+    }
+
+    public DataMapper(String targetName, String sourceName) {
+        this.targetName = targetName;
+        this.sourceName = sourceName;
+    }
+
+    public boolean isAdd() {
+        return add;
+    }
+
+    public void setAdd(boolean add) {
+        this.add = add;
+    }
+
+    public boolean isReplace() {
+        return replace;
+    }
+
+    public void setReplace(boolean replace) {
+        this.replace = replace;
+    }
+
+    public Map<Long, Long> getIdCache() {
+        return idCache;
+    }
+
+    public void setIdCache(Map<Long, Long> idCache) {
+        this.idCache = idCache;
+    }
+
+    public boolean isRemove() {
+        return remove;
+    }
+
+    public void setRemove(boolean remove) {
+        this.remove = remove;
+    }
+
+    public boolean isUpdate() {
+        return update;
+    }
+
+    public void setUpdate(boolean update) {
+        this.update = update;
+    }
+
+    public String getTargetName() {
+        return targetName;
+    }
+
+    public void setTargetName(String targetName) {
+        this.targetName = targetName;
+    }
+
+    public Object getTargetValue() {
+        return targetValue;
+    }
+
+    public void setTargetValue(Object targetValue) {
+        this.targetValue = targetValue;
+    }
+
+    public Long getTargetId() {
+        return targetId;
+    }
+
+    public void setTargetId(Long targetId) {
+        this.targetId = targetId;
+    }
+
+    public String getSourceName() {
+        return sourceName;
+    }
+
+    public void setSourceName(String sourceName) {
+        this.sourceName = sourceName;
+    }
+
+    public Object getSourceValue() {
+        return sourceValue;
+    }
+
+    public void setSourceValue(Object sourceValue) {
+        this.sourceValue = sourceValue;
+    }
+
+    public Long getSourceId() {
+        return sourceId;
+    }
+
+    public void setSourceId(Long sourceId) {
+        this.sourceId = sourceId;
+    }
+
+}

src/main/java/com/dashitech/migration/core/DataMigrationter.java

@@ -0,0 +1,84 @@
+package com.dashitech.migration.core;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 数据迁移处理
+ */
+public class DataMigrationter {
+    public static Log log = LogFactory.getLog(DataMigrationter.class);
+
+    public static void loadCache(List<Map<String, Object>> targetList, List<Map<String, Object>> sourceList, FieldMapper mapper) {
+        mapperData(targetList, sourceList, mapper);
+        trans2IdCache(mapper);
+    }
+
+    /**
+     * 待匹配字段，根据fieldList组成联合key，缓存成联合主键key:id
+     */
+    public static List<FieldMapper> mapperData(List<Map<String, Object>> targetList, List<Map<String, Object>> sourceList, FieldMapper mapper) {
+        List<FieldMapper> result = new ArrayList<>();
+        if (targetList != null && targetList.size() > 0 && sourceList != null && sourceList.size() > 0 && mapper != null && mapper.getFieldList().size() > 0) {
+
+            //源数据
+            for (Map<String, Object> map : sourceList) {
+                setSourceKey(map, mapper);
+            }
+
+            //目标数据
+            for (Map<String, Object> map : targetList) {
+                setTargetKey(map, mapper);
+            }
+
+        }
+        return result;
+    }
+
+    /**
+     * key:源数据id,value:目标数据id
+     */
+    public static void trans2IdCache(FieldMapper mapper) {
+        Map<Long, Long> cache = new HashMap<>();
+        Map<String, Long> sourceCache = mapper.getSourceCache();
+        for (Map.Entry<String, Long> entry : mapper.getTargetCache().entrySet()) {
+            Long sourceId = sourceCache.get(entry.getKey());
+            Long targetId = entry.getValue();
+            if (sourceId != null && targetId != null) {
+                cache.put(sourceId, targetId);
+            }else if(sourceId != null){
+                cache.put(sourceId, null);
+            }
+        }
+        mapper.setIdCache(cache);
+    }
+
+
+    public static void setSourceKey(Map<String, Object> map, FieldMapper mapper) {
+        StringBuffer source = new StringBuffer();
+        Object id = map.get("id");
+        for (DataMapper dataMapper : mapper.getFieldList()) {
+            Object value = map.get(dataMapper.getSourceName());
+            source.append(value).append("_");
+        }
+        source.deleteCharAt(source.length() - 1);
+        mapper.getSourceCache().put(source.toString(), id == null ? null : Long.valueOf(id.toString()));
+    }
+
+    public static void setTargetKey(Map<String, Object> map, FieldMapper mapper) {
+        StringBuffer target = new StringBuffer();
+        Object id = map.get("id");
+        for (DataMapper dataMapper : mapper.getFieldList()) {
+            Object value = map.get(dataMapper.getTargetName());
+            target.append(value).append("_");
+        }
+        target.deleteCharAt(target.length() - 1);
+        mapper.getTargetCache().put(target.toString(), id == null ? null : Long.valueOf(id.toString()));
+    }
+
+}

src/main/java/com/dashitech/migration/core/FieldMapper.java

@@ -0,0 +1,194 @@
+package com.dashitech.migration.core;
+
+import com.dashitech.migration.util.JdbcRow;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 字段匹配器
+ * Created by CX on 2024/10/10.
+ */
+public class FieldMapper {
+
+    /**
+     * 待匹配字段
+     */
+    private List<DataMapper> fieldList = new ArrayList<>();
+    private Map<String, Long> sourceCache = new HashMap<>();
+    private Map<String, Long> targetCache = new HashMap<>();
+    /**
+     * 匹配完成后的id对照，source:target
+     */
+    private Map<Long, Long> idCache = new HashMap<>();
+    /**
+     * 待转换的插入数据
+     */
+    private List<JdbcRow> rows = new ArrayList<>();
+    /**
+     * 插入数据，需要替换或删除的字段
+     */
+    private List<DataMapper> rowsOperationList = new ArrayList<>();
+
+    /**
+     * 根据rowsOperationList ,处理成可以直接插入的最终数据
+     *
+     * @param list 原始数据：List<Map<String,Object>> 类型
+     */
+    public void trans2JdbcRow(List list) {
+        if (list != null && list.size() > 0) {
+            for (Object object : list) {
+                Map<String, Object> row = (Map<String, Object>) object;
+
+                for (DataMapper dataMapper : rowsOperationList) {
+                    //如果是删除，直接删除旧key
+                    if (dataMapper.isRemove() && row.containsKey(dataMapper.getSourceName())) {
+                        row.remove(dataMapper.getSourceName());
+                    }
+                    //如果是修改，先删除旧的key，在新增新的key:value
+                    if (dataMapper.isUpdate() && row.containsKey(dataMapper.getSourceName())) {
+                        Object value = row.get(dataMapper.getSourceName());
+                        row.remove(dataMapper.getSourceName());
+                        row.put(dataMapper.getTargetName(), value);
+                    }
+                    //如果是新增，直接put
+                    if (dataMapper.isAdd()) {
+                        row.put(dataMapper.getSourceName(),dataMapper.getTargetValue());
+                    }
+                    //如果是要替换的，使用id缓存替换
+                    if (dataMapper.isReplace() && row.containsKey(dataMapper.getSourceName())) {
+                        Object value = row.get(dataMapper.getSourceName());
+                        if(value != null) {
+                            Long id = dataMapper.getIdCache().get(value);
+                            row.put(dataMapper.getSourceName(),id);
+                        }else {
+                            row.put(dataMapper.getSourceName(),null);
+                        }
+                    }
+                }
+
+                JdbcRow jdbcRow = row2JdbcRow(row);
+                rows.add(jdbcRow);
+            }
+        }
+    }
+
+    private JdbcRow row2JdbcRow(Map<String, Object> row) {
+        JdbcRow jdbcRow = new JdbcRow();
+        jdbcRow.setRow(row);
+        return jdbcRow;
+    }
+
+
+    /**
+     * 增加待匹配字段，形成联合主键key
+     */
+    public FieldMapper addFieldMapper(String target, String source) {
+        fieldList.add(new DataMapper(target, source));
+        return this;
+    }
+
+    /**
+     * 待删除的字段
+     */
+    public FieldMapper addOperationRemove(String name) {
+        DataMapper mapper = new DataMapper(name, name);
+        mapper.setRemove(true);
+        rowsOperationList.add(mapper);
+        return this;
+    }
+
+    /**
+     * 待修改的字段
+     */
+    public FieldMapper addOperationUpdate(String target, String source) {
+        DataMapper mapper = new DataMapper(target, source);
+        mapper.setUpdate(true);
+        rowsOperationList.add(mapper);
+        return this;
+    }
+
+    /**
+     * 待新增的默认字段
+     */
+    public FieldMapper addOperationAdd(String name, Object value) {
+        DataMapper mapper = new DataMapper(name, name);
+        mapper.setAdd(true);
+        mapper.setTargetValue(value);
+        rowsOperationList.add(mapper);
+        return this;
+    }
+
+    /**
+     * 待替换的字段。注意：name是旧source名称，不是新target名称，每次加入都在队列最前面
+     */
+    public FieldMapper addOperationReplace(String name, Map<Long, Long> idCache) {
+        DataMapper mapper = new DataMapper(name, name);
+        mapper.setReplace(true);
+        mapper.setIdCache(idCache);
+        //TODO 替换，必须放在第一个，避免被修改字段名称后，导致使用新名称的错误
+        rowsOperationList.add(0,mapper);
+        return this;
+    }
+
+    /**
+     * 使用完显式清空，释放内存
+     */
+    public void clear() {
+        this.fieldList.clear();
+        this.targetCache.clear();
+        this.targetCache.clear();
+        this.idCache.clear();
+        this.rows.clear();
+    }
+
+    public List<DataMapper> getFieldList() {
+        return fieldList;
+    }
+
+    public void setFieldList(List<DataMapper> fieldList) {
+        this.fieldList = fieldList;
+    }
+
+    public Map<String, Long> getSourceCache() {
+        return sourceCache;
+    }
+
+    public void setSourceCache(Map<String, Long> sourceCache) {
+        this.sourceCache = sourceCache;
+    }
+
+    public Map<String, Long> getTargetCache() {
+        return targetCache;
+    }
+
+    public void setTargetCache(Map<String, Long> targetCache) {
+        this.targetCache = targetCache;
+    }
+
+    public Map<Long, Long> getIdCache() {
+        return idCache;
+    }
+
+    public void setIdCache(Map<Long, Long> idCache) {
+        this.idCache = idCache;
+    }
+
+    public List<JdbcRow> getRows() {
+        return rows;
+    }
+
+    public void setRows(List<JdbcRow> rows) {
+        this.rows = rows;
+    }
+
+    public List<DataMapper> getRowsOperationList() {
+        return rowsOperationList;
+    }
+
+    public void setRowsOperationList(List<DataMapper> rowsOperationList) {
+        this.rowsOperationList = rowsOperationList;
+    }
+}

src/main/java/com/dashitech/migration/task/uc/GroupTask.java

@@ -0,0 +1,72 @@
+package com.dashitech.migration.task.uc;
+
+import com.dashitech.migration.BaseTask;
+import com.dashitech.migration.core.DataMigrationter;
+import com.dashitech.migration.core.FieldMapper;
+import com.dashitech.migration.util.JdbcUtil;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by CX on 2024/10/10.
+ */
+@Component
+public class GroupTask extends BaseTask {
+
+    public static Log log = LogFactory.getLog(GroupTask.class);
+
+    @Override
+    @Transactional
+    public FieldMapper start(FieldMapper fieldMapper) {
+        log.info(" *** 工作组group转换开始 *** ");
+
+        StringBuffer sb = new StringBuffer();
+        sb.append(" select * from itsm_uc_groups ");
+
+        List list = jdbcTemplateMdv2.queryForList(sb.toString());
+
+        //测试
+        FieldMapper mapper = new FieldMapper();
+        mapper.addOperationRemove("id").addOperationRemove("duty_id");
+        mapper.addOperationUpdate("_hospital_id", "branch_id");
+        mapper.addOperationAdd("type", 3);
+        Map<Long, Long> hosIdCache = new HashMap<>();
+        hosIdCache.put(1L, 4L);
+        mapper.addOperationReplace("branch_id", hosIdCache);
+        mapper.trans2JdbcRow(list);
+
+        JdbcUtil jdbcUtil = new JdbcUtil(jdbcTemplateHsms);
+        jdbcUtil.batchPageInsert("itsm_uc_groups", mapper.getRows());
+
+        //不需要缓存id的话，clear释放内存
+        mapper.clear();
+
+        mapper = loadCache();
+
+        return mapper;
+    }
+
+    @Override
+    public FieldMapper loadCache() {
+        log.info(" *** 加载工作组group缓存 *** ");
+
+        String sql = " select id,groupname,delete_flag from itsm_uc_groups ";
+        List<Map<String, Object>> list = jdbcTemplateHsms.queryForList(sql);
+        sql = " select id,groupname,delete_flag from itsm_uc_groups ";
+        List<Map<String, Object>> list2 = jdbcTemplateMdv2.queryForList(sql);
+
+        FieldMapper mapper = new FieldMapper();
+        mapper.addFieldMapper("groupname", "groupname");
+        mapper.addFieldMapper("delete_flag", "delete_flag");
+
+        DataMigrationter.loadCache(list, list2, mapper);
+
+        return mapper;
+    }
+}

src/main/java/com/dashitech/migration/task/uc/UserTask.java

@@ -0,0 +1,44 @@
+package com.dashitech.migration.task.uc;
+
+import com.dashitech.migration.BaseTask;
+import com.dashitech.migration.core.DataMigrationter;
+import com.dashitech.migration.core.FieldMapper;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by CX on 2024/10/10.
+ */
+@Component
+public class UserTask extends BaseTask {
+
+    public static Log log = LogFactory.getLog(UserTask.class);
+
+    @Override
+    @Transactional
+    public FieldMapper start(FieldMapper fieldMapper) {
+        log.info(" *** 用户user转换开始 *** ");
+
+        StringBuffer sb = new StringBuffer();
+        sb.append(" select * from itsm_uc_user ");
+
+        List list = jdbcTemplateHsms.queryForList(sb.toString());
+
+
+        return fieldMapper;
+    }
+
+    @Override
+    public FieldMapper loadCache() {
+        log.info(" *** 加载用户user缓存 *** ");
+
+
+
+        return null;
+    }
+}

src/main/java/com/dashitech/migration/util/JdbcRow.java

@@ -0,0 +1,78 @@
+package com.dashitech.migration.util;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * JdbcUtil工具类使用，表示一行数据的新增或者修改
+ * Created by CX on 2020/10/14.
+ */
+public class JdbcRow {
+
+    private Map<String, Object> row = new LinkedHashMap<String, Object>();
+    private List params = new ArrayList();
+    private StringBuffer where = new StringBuffer(" where 1 = 1 ");
+
+    public static JdbcRow newInstance() {
+        return new JdbcRow();
+    }
+
+    /**
+     * 设置行的数据项
+     * @param field 数据库字段名称
+     * @param value 需存储数据
+     */
+    public JdbcRow setAttribute(String field,Object value) {
+        row.put(field, value);
+        return this;
+    }
+
+    /**
+     * 设置简单等于的参数，这样就不用追加参数了
+     * @param field 数据库表的字段名称
+     * @param value 匹配数据
+     */
+    public JdbcRow setWhere(String field,Object value) {
+        where.append(" and ");
+        where.append(field);
+        where.append(" = ? ");
+        params.add(value);
+        return this;
+    }
+
+    /**
+     * 自定义查询语句，自己选择，怎么拼接sql。可以是 and ,or , = ,in ,BETWEEN ,order by ,group by 等任何语句
+     */
+    public JdbcRow setWhere(String condition) {
+        where.append(" ");
+        where.append(condition);
+        where.append(" ");
+        return this;
+    }
+
+    /**
+     * 手动追加参数
+     */
+    public JdbcRow setParams(String value) {
+        params.add(value);
+        return this;
+    }
+
+    public Map<String, Object> getRow() {
+        return row;
+    }
+
+    public void setRow(Map<String, Object> row) {
+        this.row = row;
+    }
+
+    public String getWhere() {
+        return where.toString();
+    }
+
+    public List getParams() {
+        return params;
+    }
+}

src/main/java/com/dashitech/migration/util/JdbcUtil.java

@@ -0,0 +1,258 @@
+package com.dashitech.migration.util;
+
+import com.dashitech.utils.CommonUtil;
+import com.dashitech.utils.DateUtil;
+import com.dashitech.utils.DecimalUtil;
+import com.dashitech.utils.SpringContextHolder;
+import org.apache.commons.lang.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.annotation.AnnotationUtils;
+import org.springframework.jdbc.core.BatchPreparedStatementSetter;
+import org.springframework.jdbc.core.BeanPropertyRowMapper;
+import org.springframework.jdbc.core.JdbcTemplate;
+
+import javax.persistence.Column;
+import javax.persistence.JoinColumn;
+import javax.persistence.Table;
+import java.beans.BeanInfo;
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.math.BigInteger;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.*;
+
+
+/**
+ * 数据库批量操作工具类
+ */
+public class JdbcUtil {
+    private static final Logger log = LoggerFactory.getLogger(JdbcUtil.class);
+    private JdbcTemplate jdbcTemplate;
+
+    public JdbcUtil(JdbcTemplate jdbcTemplate) {
+        this.jdbcTemplate = jdbcTemplate;
+    }
+
+
+
+    /**
+     * 获取插入语句
+     */
+    private String getInsertSql(String table,List<JdbcRow> rows) {
+        Map<String, Object> cols = new LinkedHashMap<>();
+
+        //顺序覆盖参数和传值
+        for (JdbcRow row : rows) {
+            cols.putAll(row.getRow());
+        }
+        //整理数据，没有的传值，补null
+        for (JdbcRow row : rows) {
+            Map<String, Object> _row = row.getRow();
+            for(Map.Entry<String,Object> entry : cols.entrySet()) {
+                //没有这个参数的，补齐null值，要不然批量新增参数不对报错
+                if(!_row.containsKey(entry.getKey())) {
+                    _row.put(entry.getKey(), null);
+                }
+            }
+        }
+
+        String result = "";
+        StringBuffer sb = new StringBuffer();
+        // 设置执行语句
+        sb.append("insert into " + table + "( ");
+        for (Map.Entry<String, Object> entry : cols.entrySet()) {
+            sb.append(entry.getKey()).append(",");
+        }
+        if (sb.toString().endsWith(",")) {
+            sb = sb.delete(sb.length() - 1, sb.length());
+        }
+        sb.append(" ) values( ");
+        for (Map.Entry<String, Object> entry : cols.entrySet()) {
+            sb.append("?,");
+        }
+        if (sb.toString().endsWith(",")) {
+            sb = sb.delete(sb.length() - 1, sb.length());
+        }
+        sb.append(" )");    //批量语句，结尾不能加上分号;
+        result = sb.toString();
+        return result;
+    }
+
+    /**
+     * 获取修改语句，必须带上条件！
+     */
+    private static String getUpdateSql(String table,JdbcRow row) {
+        String result = "";
+        StringBuffer sb = new StringBuffer();
+        // 设置执行语句
+        sb.append(" update " + table + " set ");
+        for (Map.Entry<String, Object> entry : row.getRow().entrySet()) {
+            sb.append(entry.getKey()).append(" = ? ").append(",");
+        }
+        if (sb.toString().endsWith(",")) {
+            sb = sb.delete(sb.length() - 1, sb.length());
+        }
+
+        //设置条件语句
+        sb.append(row.getWhere());
+        //批量语句，结尾不能加上分号;
+        result = sb.toString();
+        return result;
+    }
+
+
+    /**
+     * 批量执行修改数据
+     */
+    private boolean jdbcTemplateBatchUpdate(String sql, final List<JdbcRow> rows) {
+        if (jdbcTemplate != null && StringUtils.isNotEmpty(sql) && rows != null && rows.size() > 0) {
+            jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
+                public void setValues(PreparedStatement ps, int i) throws SQLException {
+                    //设置数据参数
+                    Map<String, Object> row = rows.get(i).getRow();
+                    int index = 1;
+                    for (Map.Entry<String, Object> entry : row.entrySet()) {
+                        ps.setObject(index++, entry.getValue());
+                    }
+
+                    //设置where参数
+                    List params = rows.get(i).getParams();
+                    if (params.size() > 0) {
+                        for (Object param : params) {
+                            ps.setObject(index++, param);
+                        }
+                    }
+                }
+
+                public int getBatchSize() {
+                    return rows == null ? 0 : rows.size();
+                }
+            });
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 批量执行新增数据 <br/>
+     * 新增不需要where条件
+     * @param table        插入数据的表名
+     * @param rows         行数据
+     */
+    private boolean batchInsert(String table, final List<JdbcRow> rows) {
+        if (table == null || table.length()== 0 || rows == null || rows.size() == 0) {
+            return false;
+        }
+        String insertSql = getInsertSql(table,rows);
+        log.info("开始批量新增"+table+", 条数："+rows.size());
+        return jdbcTemplateBatchUpdate(insertSql, rows);
+    }
+
+    /**
+     * 批量执行修改数据 <br/>
+     * 修改必须带上where条件
+     * @param table        插入数据的表名
+     * @param rows         行数据
+     */
+    private boolean batchUpdate(String table, final List<JdbcRow> rows) {
+        if (table == null || table.length()== 0 || rows == null || rows.size() == 0) {
+            return false;
+        }
+        String updateSql = getUpdateSql(table,rows.get(0));
+        log.info("开始批量修改"+table+", 条数："+rows.size());
+        return jdbcTemplateBatchUpdate(updateSql, rows);
+    }
+
+    /**
+     * 返回分页后的列表
+     * @param rows 总数据
+     * @param page 一批要分为多少条
+     */
+    private static List<List<JdbcRow>> pageList(List<JdbcRow> rows,int page) {
+        List<List<JdbcRow>> result = new ArrayList<List<JdbcRow>>();
+        if(rows != null && rows.size() > page) {
+            double div = Math.ceil(DecimalUtil.div(rows.size(),page).doubleValue());
+            int total = Double.valueOf(div).intValue();
+
+            for (int i = 1; i <= total; i++) {
+                List<JdbcRow> tempList = CommonUtil.paginateList(rows, i, page);
+                result.add(tempList);
+            }
+        }else if(rows != null && rows.size() > 0 && rows.size() <= page) {
+            result.add(rows);
+        }
+        return result;
+    }
+
+
+    /**
+     * 分批执行批量操作，默认1000条
+     */
+    public boolean batchPageInsert(String table, final List<JdbcRow> rows) {
+        if (table == null || table.length()== 0 || rows == null || rows.size() == 0) {
+            return false;
+        }
+        List<List<JdbcRow>> pageList = pageList(rows, 1000);
+        for (List<JdbcRow> jdbcRows : pageList) {
+            batchInsert(table, jdbcRows);
+        }
+        return true;
+    }
+
+    /**
+     * 分批执行批量操作，默认1000条
+     */
+    public boolean batchPageUpdate(String table, final List<JdbcRow> rows) {
+        if (table == null || table.length()== 0 || rows == null || rows.size() == 0) {
+            return false;
+        }
+        List<List<JdbcRow>> pageList = pageList(rows, 1000);
+        for (List<JdbcRow> jdbcRows : pageList) {
+            batchUpdate(table, jdbcRows);
+        }
+        return true;
+    }
+
+
+    public <T> List<T> simpleSelectDto(String sql,Class<T> _class,Object... args) {
+        return  jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(_class), args);
+    }
+
+    /**
+     * 返回列表的查询
+     */
+    public List simpleSelectList(String sql,Object... args) {
+        return  jdbcTemplate.queryForList(sql, args);
+    }
+
+    public static void test() {
+        List<JdbcRow> rows = new ArrayList<JdbcRow>();
+        rows.add(JdbcRow.newInstance()
+                .setAttribute("version", 1)
+                .setAttribute("_name", "fafdsafsda")
+                .setAttribute("_age", 1111)
+//                .setWhere("id",30041)
+        );
+
+        rows.add(JdbcRow.newInstance()
+                .setAttribute("version", 2)
+                .setAttribute("_name", "BBBBB131232132132121BBBBBB")
+                .setAttribute("_age", 22222)
+//                .setWhere("id",30042)
+        );
+
+//        JdbcUtil.batchInsert("test",rows);
+//        JdbcUtil.batchUpdate("test",rows);
+
+    }
+
+
+    public static void main(String[] args) {
+        test();
+    }
+
+}

src/main/java/com/dashitech/redis/core/JedisPoolFactory.java

@@ -0,0 +1,71 @@
+package com.dashitech.redis.core;
+
+import com.dashitech.utils.PropertiesUtil;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPool;
+import redis.clients.jedis.JedisPoolConfig;
+
+/**
+ * Redis抽象工厂实例类，务必在Spring的数据库配置加载完成后在调用此类！否则会报错
+ * Created by CX on 2018/8/20 0020.
+ */
+public abstract class JedisPoolFactory {
+    private static JedisPool pool;
+
+
+    private synchronized static JedisPool getJedisPool() {
+        if (pool == null) {
+            String host = PropertiesUtil.getProperty("spring.redis.host");
+            Integer port = PropertiesUtil.getInteger("spring.redis.port");
+            String password = PropertiesUtil.getProperty("spring.redis.password");
+            JedisPoolConfig config = new JedisPoolConfig();
+            config.setMaxTotal(PropertiesUtil.getInteger("spring.redis.pool.max-total"));
+            config.setMaxIdle(PropertiesUtil.getInteger("spring.redis.pool.max-idle"));
+            config.setMaxWaitMillis(PropertiesUtil.getInteger("spring.redis.pool.max-wait-millis"));
+            config.setTestOnBorrow(true);
+            pool = new JedisPool(config, host, port,2000,password);
+        }
+        return pool;
+    }
+
+
+    private synchronized static JedisPool getDefaultJedisPool() {
+        if (pool == null) {
+            String host = "127.0.0.1";
+            Integer port = 6379;
+            JedisPoolConfig config = new JedisPoolConfig();
+            config.setMaxTotal(100);
+            config.setMaxIdle(20);
+            config.setMaxWaitMillis(10000);
+            config.setTestOnBorrow(true);
+            pool = new JedisPool(config, host, port);
+        }
+        return pool;
+    }
+
+    /**
+     * 使用默认127.0.0.1和默认6379端口
+     *
+     * @return
+     */
+    public synchronized static Jedis getDefaultJedis() {
+        if (pool == null) {
+            return getDefaultJedisPool().getResource();
+        } else {
+            return pool.getResource();
+        }
+    }
+
+
+    /**
+     * 读数据库userRedisIp和userRedisPort，如果没有读取到报错
+     */
+    public synchronized static Jedis getJedis() {
+        if (pool == null) {
+            return getJedisPool().getResource();
+        } else {
+            return pool.getResource();
+        }
+    }
+
+}

src/main/java/com/dashitech/redis/core/RedisHashCmd.java

@@ -0,0 +1,162 @@
+package com.dashitech.redis.core;
+
+import redis.clients.jedis.Jedis;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Redis键值队列，元素key不可重复，注意并发问题
+ * Created by CX on 2018/8/20 0020.
+ */
+public class RedisHashCmd {
+
+    public static void main(String[] args) {
+        Map<String, String> map = new HashMap<>();
+        map.put("A", "1");
+        map.put("B", "2");
+
+        JedisPoolFactory.getDefaultJedis();
+        RedisHashCmd redisMap = new RedisHashCmd();
+        redisMap.putAll("MapA", map);
+
+
+        redisMap.put("MapA", "C", "3");
+        redisMap.put("MapA", "C", "4");
+
+        System.out.println(redisMap.containsKey("MapA", "C"));
+        System.out.println(redisMap.get("MapA", "C"));
+        System.out.println(redisMap.values("MapA"));
+        redisMap.remove("MapA", "A");
+
+        redisMap.drop("MapA");
+    }
+
+    /**
+     * 新增，如果队列不存在，新建这个队列，如果存在直接覆盖键和值
+     *
+     * @param name  队列名称
+     * @param key   主键
+     * @param value 值
+     */
+    public static void put(String name, String key, String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.hset(name, key, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 批量新增，如果队列不存在，新建这个队列，如果存在直接覆盖键和值
+     */
+    public static void putAll(String name, Map<String, String> map) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.hmset(name, map);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 删除key和对应值
+     */
+    public static void remove(String name, String key) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.hdel(name, key);
+        }catch (Exception ex) {
+            ex.printStackTrace();
+        }finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 直接删除队列本身
+     */
+    public static void drop(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.del(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 获取key对应值
+     */
+    public static String get(String name, String key) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hget(name, key);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * key集合
+     */
+    public static Set<String> keySet(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hkeys(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * value集合
+     */
+    public static List<String> values(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hvals(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    public static Map<String, String> getAll(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hgetAll(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 是否存在这个key
+     */
+    public static boolean containsKey(String name, String key) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hexists(name, key);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 队列大小
+     */
+    public static Long size(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.hlen(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+}

src/main/java/com/dashitech/redis/core/RedisKeys.java

@@ -0,0 +1,41 @@
+package com.dashitech.redis.core;
+
+/**
+ * Created by chi on 2020/6/12.
+ */
+public class RedisKeys {
+
+    /**
+     * 自动建单订阅
+     */
+    public static final String ITSM_ORDER_CREATE_PUBSUB = "itsm_order_create_pubsub";
+
+    /**
+     * 任务类型
+     */
+    public static final String ITSM_TASKTYPE_HASH = "itsm_taskType_hash";
+
+    /**
+     * 自动建单，消息队列
+     */
+    public static final String ITSM_CREATE_ORDER_LIST = "itsm_create_order_list";
+    public static final String ITSM_FLOW_ORDER_LIST = "itsm_flow_order_list";
+
+    /**
+     * 科室变更消息订阅
+     */
+    public static final String ITSM_DEPT_CHANGED_PUBSUB = "itsm_dept_changed_pubsub";
+
+
+    /**
+     * 手术临床消息
+     */
+    public static final String ITSM_SURGERY_CLINICAL_MSG_LIST = "itsm_surgery_clinical_msg_list";
+
+
+    /**
+     * 字典表变更消息订阅
+     */
+    public static final String ITSM_DICTIONARY_CHANGED_PUBSUB = "itsm_dictionary_changed_pubsub";
+
+}

src/main/java/com/dashitech/redis/core/RedisListCmd.java

@@ -0,0 +1,181 @@
+package com.dashitech.redis.core;
+
+import redis.clients.jedis.Jedis;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Redis队列，元素可重复，注意并发问题
+ * Created by CX on 2018/8/20 0020.
+ */
+public class RedisListCmd {
+
+    public static void main(String[] args) {
+        JedisPoolFactory.getDefaultJedis();
+        RedisListCmd redisList = new RedisListCmd();
+
+        redisList.add("AAAAAAAAA", "A");
+        redisList.add("AAAAAAAAA", "B");
+        redisList.add("AAAAAAAAA", 0, "C");
+        redisList.add("AAAAAAAAA", "A");
+
+        List<String> list = new ArrayList<>();
+        list.add("1111");
+        list.add("2222");
+        redisList.addAll("AAAAAAAAA", list);
+
+        System.out.println(redisList.indexOf("AAAAAAAAA", "A"));
+        System.out.println(redisList.contains("AAAAAAAAA", "B"));
+        System.out.println(redisList.get("AAAAAAAAA", 1));
+        System.out.println(redisList.get("AAAAAAAAA"));
+        System.out.println(redisList.size("AAAAAAAAA"));
+
+        redisList.remove("AAAAAAAAA", "B");
+
+        redisList.drop("AAAAAAAAA");
+
+    }
+
+    /**
+     * 新增，如果队列不存在，新建这个队列，如果存在插入值到队列最后面
+     *
+     * @param name  队列名称
+     * @param value 值
+     */
+    public static void add(String name, String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.rpush(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 在指定下标插入值，注意！原下标值会被当前值覆盖！如果下标出错，会报错
+     */
+    public static void add(String name, int index, String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.lset(name, index, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 批量新增，如果队列不存在，新建这个队列，如果存在插入值到队列最后面
+     */
+    public static void addAll(String name, List<String> list) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            if (list != null && list.size() > 0) {
+                String[] values = new String[list.size()];
+                for (int i = 0; i < list.size(); i++) {
+                    values[i] = list.get(i);
+                }
+                jedis.rpush(name, values);
+            }
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 删除所有和value值相等的对象
+     */
+    public static void remove(String name, String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.lrem(name, 0, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 直接删除队列本身
+     */
+    public static void drop(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.del(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 根据下标获取值
+     */
+    public static String get(String name, int index) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.lindex(name, index);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 获取所有值
+     */
+    public static List<String> get(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.lrange(name, 0, -1);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 获取并移除列表第一个值，如果队列空了，返回null
+     */
+    public static String pop(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.lpop(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 直接比对返回下标
+     */
+    public static int indexOf(String name, String value) {
+        List<String> list = get(name);
+        if (list != null && list.size() > 0) {
+            for (int i = 0; i < list.size(); i++) {
+                String _value = list.get(i);
+                if (_value.equals(value)) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+
+    /**
+     * 直接返回是否包含
+     */
+    public static boolean contains(String name, String value) {
+        int index = indexOf(name, value);
+        return index > -1;
+    }
+
+    /**
+     * 队列大小
+     */
+    public static Long size(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.llen(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+}

src/main/java/com/dashitech/redis/core/RedisPubSubCmd.java

@@ -0,0 +1,46 @@
+package com.dashitech.redis.core;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.JedisPubSub;
+
+/**
+ * Redis发布和订阅
+ * Created by CX on 2018/8/20 0020.
+ */
+public class RedisPubSubCmd {
+    private static Log log = LogFactory.getLog(RedisPubSubCmd.class);
+
+    public static void main(String[] args) {
+        JedisPoolFactory.getDefaultJedis();
+
+    }
+
+    public static boolean subscribe(JedisPubSub jedisPubSub, String topic) {
+        final Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.subscribe(jedisPubSub, topic);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return false;
+        } finally {
+            jedis.close();
+        }
+        return true;
+    }
+
+
+    public static void publish(String topic, String message) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.publish(topic, message);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        } finally {
+            jedis.close();
+        }
+    }
+
+
+}

src/main/java/com/dashitech/redis/core/RedisQueueMonitor.java

@@ -0,0 +1,5 @@
+package com.dashitech.redis.core;
+
+
+public class RedisQueueMonitor {
+}

src/main/java/com/dashitech/redis/core/RedisStringCmd.java

@@ -0,0 +1,149 @@
+package com.dashitech.redis.core;
+
+import redis.clients.jedis.Jedis;
+
+/**
+ * Redis字符串，注意并发问题
+ * Created by CX on 2018/8/20 0020.
+ */
+public class RedisStringCmd {
+
+    public static void main(String[] args) {
+        JedisPoolFactory.getDefaultJedis();
+
+        RedisStringCmd.drop("testString");
+        RedisStringCmd.set("testString","ABC");
+        System.out.println(RedisStringCmd.getset("testString", "CBA"));
+        System.out.println(RedisStringCmd.getset("testString111", "CBA"));
+        RedisStringCmd.append("testString","DEF");
+        System.out.println(RedisStringCmd.get("testString"));
+    }
+
+    /**
+     * 新增，如果已存在，覆盖当前值
+     * @param name  名称
+     * @param value 值
+     */
+    public static void set(String name, String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.set(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    public static void set(byte[] name, byte[] value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.set(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 有生命周期的新增，如果已存在，覆盖当前值和时间
+     * @param seconds  时间秒数
+     */
+    public static void setex(String name, String value,int seconds) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.setex(name, seconds,value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    public static void setex(byte[] name, byte[] value,int seconds) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.setex(name, seconds, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     *  key不存在时才成功
+     * @return 成功1 失败 0
+     */
+    public static Long setnx(String name,String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.setnx(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 设置值，并返回旧值，旧值不存在时返回null
+     */
+    public static String getset(String name,String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+           return jedis.getSet(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 追加值到末尾，如果不存在key，新增
+     */
+    public static void append(String name,String value) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.append(name, value);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 直接删除key
+     */
+    public static void drop(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            jedis.del(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 获取值
+     */
+    public static String get(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.get(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    public static byte[] get(byte[] name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.get(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+    /**
+     * 值大小
+     */
+    public static Long size(String name) {
+        Jedis jedis = JedisPoolFactory.getJedis();
+        try {
+            return jedis.strlen(name);
+        } finally {
+            jedis.close();
+        }
+    }
+
+}

src/main/java/com/dashitech/utils/CaptchaUtil.java

@@ -0,0 +1,107 @@
+package com.dashitech.utils;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.image.BufferedImage;
+import java.io.IOException;
+import java.util.Random;
+
+import javax.imageio.ImageIO;
+import javax.servlet.http.HttpServletResponse;
+
+public class CaptchaUtil {
+	
+	private String code = "";
+	private BufferedImage image;
+	
+	public String getCode() {
+		return code;
+	}
+	public void setCode(String code) {
+		this.code = code;
+	}
+	public BufferedImage getImage() {
+		return image;
+	}
+	public void setImage(BufferedImage image) {
+		this.image = image;
+	}
+	
+	public CaptchaUtil() {
+		init();
+	}
+
+	private Color getRandColor(int fc, int bc) {// 给定范围获得随机颜色
+		Random random = new Random();
+		if (fc > 255)
+			fc = 255;
+		if (bc > 255)
+			bc = 255;
+		int r = fc + random.nextInt(bc - fc);
+		int g = fc + random.nextInt(bc - fc);
+		int b = fc + random.nextInt(bc - fc);
+		return new Color(r, g, b);
+	}
+
+	private void init() {
+		// 在内存中创建图象
+		int width=60, height=20;
+		image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+		
+		// 获取图形上下文
+		Graphics g = image.getGraphics();
+		
+		//生成随机类
+		Random random = new Random();
+		
+		// 设定背景色
+		g.setColor(getRandColor(200,250));
+		g.fillRect(0, 0, width, height);
+		
+		//设定字体
+		g.setFont(new Font("Times New Roman",Font.PLAIN,18));
+		
+		//画边框
+		//g.setColor(new Color());
+		//g.drawRect(0,0,width-1,height-1);
+		
+		// 随机产生155条干扰线，使图象中的认证码不易被其它程序探测到
+		g.setColor(getRandColor(160,200));
+		for (int i=0;i<155;i++)
+		{
+		 int x = random.nextInt(width);
+		 int y = random.nextInt(height);
+		        int xl = random.nextInt(12);
+		        int yl = random.nextInt(12);
+		 g.drawLine(x,y,x+xl,y+yl);
+		}
+		
+		// 取随机产生的认证码(4位数字)
+		for (int i=0;i<4;i++){
+		    String rand=String.valueOf(random.nextInt(10));
+		    code+=rand;
+		    // 将认证码显示到图象中
+		    g.setColor(new Color(20+random.nextInt(110),20+random.nextInt(110),20+random.nextInt(110)));
+		//调用函数出来的颜色相同，可能是因为种子太接近，所以只能直接生成
+		    g.drawString(rand,13*i+6,16);
+		}
+		
+		// 图象生效
+		g.dispose();
+		
+	}
+	
+	public static void writeCaptcha(HttpServletResponse resp,CaptchaUtil captcha) {
+		resp.setHeader("Pragma","No-cache");
+		resp.setHeader("Cache-Control","no-cache");
+		resp.setDateHeader("Expires", 0);
+		BufferedImage image = captcha.getImage();
+		// 输出图象到页面
+		try {
+			ImageIO.write(image, "JPEG", resp.getOutputStream());
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+}

src/main/java/com/dashitech/utils/CaptchaUtil2.java

@@ -0,0 +1,228 @@
+package com.dashitech.utils;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics;
+import java.awt.image.BufferedImage;
+import java.util.Random;
+
+public class CaptchaUtil2 {
+
+	/**
+	 * 验证码类型为仅数字,即0~9
+	 */
+	public static final int TYPE_NUM_ONLY = 0;
+
+	/**
+	 * 验证码类型为仅字母,即大小写字母混合
+	 */
+	public static final int TYPE_LETTER_ONLY = 1;
+
+	/**
+	 * 验证码类型为数字和大小写字母混合
+	 */
+	public static final int TYPE_ALL_MIXED = 2;
+
+	/**
+	 * 验证码类型为数字和大写字母混合
+	 */
+	public static final int TYPE_NUM_UPPER = 3;
+
+	/**
+	 * 验证码类型为数字和小写字母混合
+	 */
+	public static final int TYPE_NUM_LOWER = 4;
+
+	/**
+	 * 验证码类型为仅大写字母
+	 */
+	public static final int TYPE_UPPER_ONLY = 5;
+
+	/**
+	 * 验证码类型为仅小写字母
+	 */
+	public static final int TYPE_LOWER_ONLY = 6;
+
+	/**
+	 * 生成随机颜色
+	 */
+	private static Color generateRandomColor() {
+		Random random = new Random();
+		return new Color(random.nextInt(255), random.nextInt(255), random.nextInt(255));
+	}
+
+	/**
+	 * 生成图片验证码
+	 * 
+	 * @param type
+	 *            验证码类型,参见本类的静态属性
+	 * @param length
+	 *            验证码字符长度,要求大于0的整数
+	 * @param excludeString
+	 *            需排除的特殊字符
+	 * @param width
+	 *            图片宽度(注意此宽度若过小,容易造成验证码文本显示不全,如4个字符的文本可使用85到90的宽度)
+	 * @param height
+	 *            图片高度
+	 * @param interLine
+	 *            图片中干扰线的条数
+	 * @param randomLocation
+	 *            每个字符的高低位置是否随机
+	 * @param backColor
+	 *            图片颜色,若为null则表示采用随机颜色
+	 * @param foreColor
+	 *            字体颜色,若为null则表示采用随机颜色
+	 * @param lineColor
+	 *            干扰线颜色,若为null则表示采用随机颜色
+	 * @return 图片缓存对象
+	 */
+	public static BufferedImage generateImageCode(int type, int length, String excludeString, int width, int height, int interLine, boolean randomLocation, Color backColor, Color foreColor, Color lineColor) {
+		String textCode = generateTextCode(type, length, excludeString);
+		return generateImageCode(textCode, width, height, interLine, randomLocation, backColor, foreColor, lineColor);
+	}
+
+	/**
+	 * 生成验证码字符串
+	 * 
+	 * @param type
+	 *            验证码类型,参见本类的静态属性
+	 * @param length
+	 *            验证码长度,要求大于0的整数
+	 * @param excludeString
+	 *            需排除的特殊字符（无需排除则为null）
+	 * @return 验证码字符串
+	 */
+	public static String generateTextCode(int type, int length, String excludeString) {
+		if (length <= 0) {
+			return "";
+		}
+		StringBuffer verifyCode = new StringBuffer();
+		int i = 0;
+		Random random = new Random();
+		switch (type) {
+		case TYPE_NUM_ONLY:
+			while (i < length) {
+				int t = random.nextInt(10);
+				// 排除特殊字符
+				if (null == excludeString || excludeString.indexOf(t + "") < 0) {
+					verifyCode.append(t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_LETTER_ONLY:
+			while (i < length) {
+				int t = random.nextInt(123);
+				if ((t >= 97 || (t >= 65 && t <= 90)) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_ALL_MIXED:
+			while (i < length) {
+				int t = random.nextInt(123);
+				if ((t >= 97 || (t >= 65 && t <= 90) || (t >= 48 && t <= 57)) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_NUM_UPPER:
+			while (i < length) {
+				int t = random.nextInt(91);
+				if ((t >= 65 || (t >= 48 && t <= 57)) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_NUM_LOWER:
+			while (i < length) {
+				int t = random.nextInt(123);
+				if ((t >= 97 || (t >= 48 && t <= 57)) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_UPPER_ONLY:
+			while (i < length) {
+				int t = random.nextInt(91);
+				if ((t >= 65) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		case TYPE_LOWER_ONLY:
+			while (i < length) {
+				int t = random.nextInt(123);
+				if ((t >= 97) && (null == excludeString || excludeString.indexOf((char) t) < 0)) {
+					verifyCode.append((char) t);
+					i++;
+				}
+			}
+			break;
+		}
+		return verifyCode.toString();
+	}
+
+	/**
+	 * 已有验证码,生成验证码图片
+	 * 
+	 * @param textCode
+	 *            文本验证码
+	 * @param width
+	 *            图片宽度(注意此宽度若过小,容易造成验证码文本显示不全,如4个字符的文本可使用85到90的宽度)
+	 * @param height
+	 *            图片高度
+	 * @param interLine
+	 *            图片中干扰线的条数
+	 * @param randomLocation
+	 *            每个字符的高低位置是否随机
+	 * @param backColor
+	 *            图片颜色,若为null则表示采用随机颜色
+	 * @param foreColor
+	 *            字体颜色,若为null则表示采用随机颜色
+	 * @param lineColor
+	 *            干扰线颜色,若为null则表示采用随机颜色
+	 * @return 图片缓存对象
+	 */
+	public static BufferedImage generateImageCode(String textCode, int width, int height, int interLine, boolean randomLocation, Color backColor, Color foreColor, Color lineColor) {
+		// 创建内存图像
+		BufferedImage bufferedImage = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+		// 获取图形上下文
+		Graphics graphics = bufferedImage.getGraphics();
+		// 画背景图
+		graphics.setColor(null == backColor ? generateRandomColor() : backColor);
+		graphics.fillRect(0, 0, width, height);
+		// 画干扰线
+		Random random = new Random();
+		if (interLine > 0) {
+			int x = 0, y = 0, x1 = width, y1 = 0;
+			for (int i = 0; i < interLine; i++) {
+				graphics.setColor(null == lineColor ? generateRandomColor() : lineColor);
+				y = random.nextInt(height);
+				y1 = random.nextInt(height);
+				graphics.drawLine(x, y, x1, y1);
+			}
+		}
+		// 字体大小为图片高度的80%
+		int fsize = (int) (height * 0.8);
+		int fx = height - fsize;
+		int fy = fsize;
+		// 设定字体
+		graphics.setFont(new Font("Default", Font.PLAIN, fsize));
+		// 写验证码字符
+		for (int i = 0; i < textCode.length(); i++) {
+			fy = randomLocation ? (int) ((Math.random() * 0.3 + 0.6) * height) : fy;
+			graphics.setColor(null == foreColor ? generateRandomColor() : foreColor);
+			// 将验证码字符显示到图象中
+			graphics.drawString(textCode.charAt(i) + "", fx, fy);
+			fx += fsize * 0.9;
+		}
+		graphics.dispose();
+		return bufferedImage;
+	}
+}

src/main/java/com/dashitech/utils/CommonUtil.java

@@ -0,0 +1,250 @@
+package com.dashitech.utils;
+
+import org.apache.commons.lang.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+import java.util.*;
+
+/**
+ * 混杂工具类
+ * Created by CX on 2017/3/31 0031.
+ */
+public class CommonUtil {
+    private static final Logger LOG = LoggerFactory.getLogger(CommonUtil.class);
+
+    private CommonUtil(){}
+
+    public static <T> List<?> transList(List<?> list) {
+        return list;
+    }
+
+    /**
+     * 把新地址加入到classpath中
+     * @param path 新地址,绝对路劲
+     * @return  是否成功
+     */
+    public static boolean addJavaClassPath(String path) {
+        try {
+            File programRootDir = new File(path);
+            URLClassLoader classLoader = (URLClassLoader) ClassLoader.getSystemClassLoader();
+            Method add = URLClassLoader.class.getDeclaredMethod("addURL", new Class[]{URL.class});
+            add.setAccessible(true);
+            add.invoke(classLoader, programRootDir.toURI().toURL());
+            return true;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return false;
+    }
+
+    /**
+     * 在source的下标 start和end中间插入newStr
+     */
+    public static String cutInsertString(String source, int start, int end, String newStr) {
+        String startStr = source.substring(0, start);
+        String endStr = source.substring(end, source.length());
+        String result = startStr + newStr + endStr;
+        return result;
+    }
+
+    /**
+     * 获取中文类型长度，中文长度2，其他1
+     */
+    public static int getChineseLength(String source) {
+        int valueLength = 0;
+        String chinese = "[\u0391-\uFFE5]";
+		/* 获取字段值的长度，如果含中文字符，则每个中文字符长度为2，否则为1 */
+        for (int i = 0; i < source.length(); i++) {
+			/* 获取一个字符 */
+            String temp = source.substring(i, i + 1);
+			/* 判断是否为中文字符 */
+            if (temp.matches(chinese)) {
+				/* 中文字符长度为2 */
+                valueLength += 2;
+            } else {
+				/* 其他字符长度为1 */
+                valueLength += 1;
+            }
+        }
+        return valueLength;
+    }
+
+    /**
+     * 获取翻页数
+     *
+     * @param itemTotal
+     *            总条数
+     * @param PageCount
+     *            一页数
+     * @return 翻页数
+     */
+    public static int getPageTotal(Integer itemTotal, int PageCount) {
+        // 设置总页数
+        int total = 0;
+        if (itemTotal % PageCount == 0) {
+            total = itemTotal / PageCount;
+        } else {
+            total = (itemTotal / PageCount) + 1;
+        }
+        return total;
+    }
+
+    /**
+     * 自己写sql分页必须处理pageIndex
+     */
+    public static int getPageIndex(int pageIndex,int showCount) {
+        int result = 0;
+        if(pageIndex <= 1) {
+            result = 0;
+        }else if(pageIndex > 1) {
+            result = ((pageIndex * showCount) - showCount);
+        }
+        return result;
+    }
+
+    /**
+     * url中文编码
+     */
+    public static String urlEncode(String url) {
+        String s = url;
+        try {
+            s = URLEncoder.encode(url, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+        return s;
+    }
+
+    /**
+     * url中文解码
+     */
+    public static String urlDecode(String url) {
+        String s = url;
+        try {
+            s = URLDecoder.decode(url, "UTF-8");
+        } catch (UnsupportedEncodingException e) {
+            e.printStackTrace();
+        }
+        return s;
+    }
+
+    /**
+     * 排序
+     * @param list
+     * @param field 字段名称，必须有get方法
+     * @param fieldType 字段类型
+     */
+    public static void sort(List<?> list,final String field,final String fieldType) {
+        Collections.sort(list, new Comparator<Object>() {
+            public int compare(Object o1, Object o2) {
+                Method m = null;
+                try {
+                    String getKey = "get" + field.toUpperCase().charAt(0) + field.substring(1, field.length());
+                    m = o1.getClass().getMethod(getKey);
+                    Object o1Value = m.invoke(o1);
+
+                    m = o2.getClass().getMethod(getKey);
+                    Object o2Value = m.invoke(o2);
+
+                    if(o1Value == null && o2Value == null) {
+                        return 0;
+                    }else if(o1Value == null && o2Value != null) {
+                        return -1;
+                    }else if(o1Value != null && o2Value == null) {
+                        return 1;
+                    }
+
+                    if("Integer".equals(fieldType.toString())) {
+                        Integer _o1 = (Integer)o1Value;
+                        Integer _o2 = (Integer)o2Value;
+                        return _o1.compareTo(_o2);
+                    }else if("String".equals(fieldType.toString())) {
+                        String _o1 = (String)o1Value;
+                        String _o2 = (String)o2Value;
+                        return _o1.compareTo(_o2);
+                    }else if("StringNumber".equals(fieldType.toString())) {
+                        try{
+                            Double _o1 = Double.valueOf(o1Value.toString());
+                            Double _o2 = Double.valueOf(o2Value.toString());
+                            return _o1.compareTo(_o2);
+                        }catch (NumberFormatException ex) {
+                            ex.printStackTrace();
+                        }
+                    }
+                }catch (Exception e) {
+                    e.printStackTrace();
+                }
+                return 0;
+            }
+        });
+    }
+
+    /**
+     * 逻辑分页
+     *
+     * @param src
+     *            源数据
+     * @param start
+     *            分页页数，1起始
+     * @param size
+     *            分页limit
+     * @return 新的分页后的List
+     * @throws Exception
+     */
+    public static <T> List<T> paginateList(List<T> src, int start, int size) {
+        if(src == null) {
+            return Collections.emptyList();
+        }
+
+        List<T> list = null;
+        if(start <= 1) {
+            start = 0;
+        }else {
+            start = (start-1) * size;
+        }
+
+        size = size + start;
+        if (size > src.size()) {
+            size = src.size();
+        }
+
+        try {
+            list = src.subList(start, size);
+        } catch (Exception e) {
+            System.out.println("list.size:"+src.size()+"start:" + start + " , size" + size);
+            e.printStackTrace();
+        }
+        return list;
+    }
+
+
+    /**
+     * map.toString之后，转回map
+     */
+    public static Map<String,String> string2Map(String mapString) {
+        Map<String,String> map = new LinkedHashMap<String,String>();
+        try {
+            if(StringUtils.isNotEmpty(mapString)) {
+                String args = mapString.substring(1,mapString.length()-1);
+                String[] argArr = args.split(", ");
+                for (String entry : argArr) {
+                    int index = entry.indexOf("=");
+                    String key = entry.substring(0,index);
+                    String value = entry.substring(index+1);
+                    map.put(key, value);
+                }
+            }
+        }catch (Exception ex) {
+            ex.printStackTrace();
+        }
+        return map;
+    }
+}

src/main/java/com/dashitech/utils/DateUtil.java

@@ -0,0 +1,318 @@
+package com.dashitech.utils;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+
+public class DateUtil {
+    private static final int FIRST_DAY = Calendar.MONDAY;
+    public final static SimpleDateFormat SDF_DATE = new SimpleDateFormat("yyyy-MM-dd");
+    public final static SimpleDateFormat SDF_DATETIME = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+    
+    
+	private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+	
+	public static String formatTimestamp(Date date){
+		String formattedDate = dateFormat.format(date);
+		return formattedDate;
+	}
+	
+	public static Date parseTimestamp(String text){
+		try {
+			return dateFormat.parse(text);
+		} catch (ParseException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+    private static void setToFirstDay(Calendar calendar) {
+        while (calendar.get(Calendar.DAY_OF_WEEK) != FIRST_DAY) {
+            calendar.add(Calendar.DATE, -1);
+        }
+    }
+    
+    public static String formatDateTime (Date date) {
+    	return SDF_DATETIME.format(date);
+    }
+    
+    public static String formatDate (Date date) {
+    	return SDF_DATE.format(date);
+    }
+
+	public static Date parseUTCDateTime(String date){
+		Date d = null;
+		try {
+			date = date.replace("Z", " UTC");//注意是空格+UTC
+			SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS Z");//注意格式化的表达式
+			d = format.parse(date);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		return d;
+	}
+    
+    public static Date parseDateTime(String date){
+    	Date d = null;
+    	try {
+			d = SDF_DATETIME.parse(date);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		return d;
+    }
+    
+    public static Date parseDate(String date){
+    	Date d = null;
+    	try {
+			d = SDF_DATE.parse(date);
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+		return d;
+    }
+
+    /**
+     * 从周一开始7天
+     */
+    public static List<String> getWeekdays(Date date) {
+        List<String> list = new ArrayList<String>();
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        
+        setToFirstDay(calendar);
+        
+        for (int i = 0; i < 7; i++) {
+            list.add(SDF_DATE.format(calendar.getTime()));
+            calendar.add(Calendar.DATE, 1);
+        }
+        return list;
+    }
+    
+    /**
+     * 从周一开始7天
+     */
+    public static List<String> getWeekdaysAndColor(Date date) {
+        List<String> list = new ArrayList<String>();
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        
+        setToFirstDay(calendar);
+        
+        for (int i = 0; i < 7; i++) {
+        	if(i == 6 || i == 5)
+                list.add("<font class='weekColor'>" + SDF_DATE.format(calendar.getTime()) + "</font>");
+        	else
+        		list.add(SDF_DATE.format(calendar.getTime()));
+            calendar.add(Calendar.DATE, 1);
+        }
+        return list;
+    }
+    public static String getMonday(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        setToFirstDay(calendar);
+        return SDF_DATE.format(calendar.getTime());
+    }
+    
+    public static String getSunday(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        setToFirstDay(calendar);
+        calendar.add(Calendar.DATE, 6);
+        return SDF_DATE.format(calendar.getTime());
+    }
+    
+    /**
+     * 当前日期  + 7
+     * @param date
+     * @return
+     */
+    public static Date getAfterWeekByDay(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.add(Calendar.DATE, 7);
+        return calendar.getTime();
+    }
+    
+    /**
+     * 当前日期  - 7
+     * @param date
+     * @return
+     */
+    public static Date getBeforeWeekByDay(Date date) {
+        Calendar calendar = Calendar.getInstance();
+        calendar.setTime(date);
+        calendar.add(Calendar.DATE, -7);
+        return calendar.getTime();
+    }
+
+    /**
+	 * 获取星期一
+	 * 
+	 * @param date 传入的日期
+	 * @return
+	 */
+	public static Date getMOnday(Date date) {
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(date);
+		// 判断要计算的日期是否是周日，如果是则减一天计算周六的，否则会出问题，计算到下一周去了
+		int dayWeek = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
+		if (1 == dayWeek) {
+			cal.add(Calendar.DAY_OF_MONTH, -1);
+		}
+		cal.setFirstDayOfWeek(Calendar.MONDAY);// 设置一个星期的第一天，按中国的习惯一个星期的第一天是星期一
+		int day = cal.get(Calendar.DAY_OF_WEEK);// 获得当前日期是一个星期的第几天
+		cal.add(Calendar.DATE, cal.getFirstDayOfWeek() - day);// 根据日历的规则，给当前日期减去星期几与一个星期第一天的差值
+		return cal.getTime();
+	}
+
+	/**
+	 * 判断传入的日期的周数是否大于当前日期的周数
+	 * @param dutyDate 传入的日期
+	 * @return
+	 */
+	public static boolean isBeforeThisWeek(Date dutyDate){ 
+		return getMOnday(new Date()).getTime() < getMOnday(dutyDate).getTime();
+	}
+	
+	public static boolean equals(Date d1,Date d2,SimpleDateFormat sdf) {
+	    String a = sdf.format(d1);
+	    String b = sdf.format(d2);
+	    if(a != null && b != null) {
+	        return a.equals(b);
+	    }
+	    return false;
+	}
+
+	public static String ignoreFrmat(String source,SimpleDateFormat sdf) {
+	    List<String> list = Arrays.asList("yyyy-M-d","yyyy-MM-dd","yyyy-M","yyyy-MM","yyyy/M/d","yyyy/MM/dd","yyyy/M","yyyy/MM");
+	    String result = "";
+	    for(int i = 0;i<list.size();i++) {
+	        try {
+                Date d = new SimpleDateFormat(list.get(i)).parse(source);
+                result = sdf.format(d);
+                return result;
+            } catch (Exception e) {
+                
+            }
+	    }
+	    try {
+            Date d = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy",Locale.US).parse(source);
+            result = sdf.format(d);
+        } catch (Exception e) {
+        }
+	    return result;
+	}
+	
+	public static Date ignoreFrmat_Date(String source,SimpleDateFormat sdf) {
+	    String result = ignoreFrmat(source,sdf);
+	    Date d = null;
+        try {
+            d = sdf.parse(result);
+        } catch (ParseException e) {
+            e.printStackTrace();
+        }
+	    return d;
+	}
+	
+	/**
+	 * 两个时间相差天数
+	 * date1  开始时间
+	 * date2  结束时间
+	 * 
+	 * */
+	public static int getMonthSpace(String staticTime, String endTime) throws ParseException {
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+		long startT=sdf.parse(staticTime).getTime(); //定义开始时间
+		long endT=sdf.parse(endTime).getTime();  //定义结束时间
+		long overDay=(endT-startT) /(1000 * 60 * 60 * 24);
+		int day = Integer.parseInt(String.valueOf(overDay));
+		return day;
+	}
+	
+	/**
+	 * 获取年份
+	 * */
+	private static int getYear(String date1) throws ParseException { 
+	    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
+	    Calendar cal = Calendar.getInstance(); 
+	    Date dt = null; 
+	    try { 
+	      dt = sdf.parse(date1); 
+	      cal.setTime(dt); 
+	    } catch (ParseException e) { 
+	      // TODO Auto-generated catch block 
+	      e.printStackTrace(); 
+	    } 
+	    int year = cal.get(Calendar.YEAR); 
+	    int month = cal.get(Calendar.MONTH) + 1; 
+	    int day = cal.get(Calendar.DAY_OF_MONTH); 
+	    int hour = cal.get(Calendar.HOUR_OF_DAY); 
+	    int minute = cal.get(Calendar.MINUTE); 
+	    int second = cal.get(Calendar.SECOND); 
+	    return year;
+	  }
+
+	public static boolean isInDates(Date date, Date startDate, Date endDate) {
+		SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+		Date myDate = null;
+		Date dateBegin = null;
+		Date dateEnd = null;
+		String strDate = sd.format(date);
+		String strDateBegin = sd.format(startDate);
+		String strDateEnd = sd.format(endDate);
+		try {
+			myDate = sd.parse(strDate);
+			dateBegin = sd.parse(strDateBegin);
+			dateEnd = sd.parse(strDateEnd);
+		} catch (ParseException e) {
+			// TODO Auto-generated catch block
+			e.printStackTrace();
+		}
+		strDate = String.valueOf(myDate);
+		strDateBegin = String.valueOf(dateBegin);
+		strDateEnd = String.valueOf(dateEnd);
+
+		int strDateH = Integer.parseInt(strDate.substring(11, 13));
+		int strDateM = Integer.parseInt(strDate.substring(14, 16));
+		int strDateS = Integer.parseInt(strDate.substring(17, 19));
+
+		int strDateBeginH = Integer.parseInt(strDateBegin.substring(11, 13));
+		int strDateBeginM = Integer.parseInt(strDateBegin.substring(14, 16));
+		//int strDateBeginS = Integer.parseInt(strDateBegin.substring(17,19));
+
+		int strDateEndH = Integer.parseInt(strDateEnd.substring(11, 13));
+		int strDateEndM = Integer.parseInt(strDateEnd.substring(14, 16));
+		//int strDateEndS = Integer.parseInt(strDateEnd.substring(17,19));
+
+		if ((strDateH >= strDateBeginH && strDateH <= strDateEndH)) {
+			if (strDateH > strDateBeginH && strDateH < strDateEndH) {
+				return true;
+			} else if (strDateH == strDateBeginH && strDateM > strDateBeginM && strDateH < strDateEndH) {
+				return true;
+			} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateH < strDateEndH) {
+				return true;
+			} else if (strDateH == strDateBeginH && strDateM == strDateBeginM && strDateH < strDateEndH) {
+				return true;
+			} else if (strDateH > strDateBeginH && strDateH == strDateEndH && strDateM < strDateEndM) {
+				return true;
+			} else if (strDateH > strDateBeginH && strDateH == strDateEndH && strDateM == strDateEndM) {
+				return true;
+			} else if (strDateH > strDateBeginH && strDateH == strDateEndH && strDateM == strDateEndM) {
+				return true;
+			} else {
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+	
+}	

src/main/java/com/dashitech/utils/DateUtil2.java

@@ -0,0 +1,670 @@
+package com.dashitech.utils;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang.StringUtils;
+
+public class DateUtil2 {
+
+    public static final String FORMAT_DATE = "yyyy-MM-dd";
+
+    public static final String FORMAT_TIME = "HH:mm:ss";
+
+    public static final String FORMAT_DATE_TIME = "yyyy-MM-dd HH:mm:ss";
+
+    public static final SimpleDateFormat SDFD = new SimpleDateFormat(FORMAT_DATE);
+
+    public static final SimpleDateFormat SDFT = new SimpleDateFormat(FORMAT_TIME);
+
+    public static final SimpleDateFormat SDFDT = new SimpleDateFormat(FORMAT_DATE_TIME);
+
+    /**
+     * 得到以yyyy-MM-dd格式表示的当前日期字符串
+     */
+    public static String getCurrentDate() {
+        // return sdfd.format(new Date());
+        GregorianCalendar tGCalendar = new GregorianCalendar();
+        StringBuffer tStringBuffer = new StringBuffer(10);
+        int sYears = tGCalendar.get(Calendar.YEAR);
+        tStringBuffer.append(sYears);
+        tStringBuffer.append('-');
+        int sMonths = tGCalendar.get(Calendar.MONTH) + 1;
+        if (sMonths < 10) {
+            tStringBuffer.append('0');
+        }
+        tStringBuffer.append(sMonths);
+        tStringBuffer.append('-');
+        int sDays = tGCalendar.get(Calendar.DAY_OF_MONTH);
+        if (sDays < 10) {
+            tStringBuffer.append('0');
+        }
+        tStringBuffer.append(sDays);
+        String tString = tStringBuffer.toString();
+        return tString;
+    }
+
+    /**
+     * 得到以format格式表示的当前日期字符串
+     */
+    public static String getCurrentDate(String format) {
+        SimpleDateFormat t = new SimpleDateFormat(format);
+        return t.format(new Date());
+    }
+
+    /**
+     * 得到以HH:mm:ss表示的当前时间字符串
+     */
+    public static String getCurrentTime() {
+        // return sdft.format(new Date());
+        GregorianCalendar tGCalendar = new GregorianCalendar();
+        StringBuffer tStringBuffer = new StringBuffer(8);
+        int sHOUR = tGCalendar.get(Calendar.HOUR_OF_DAY);
+        if (sHOUR < 10) {
+            tStringBuffer.append('0');
+        }
+        tStringBuffer.append(sHOUR);
+        tStringBuffer.append(':');
+        int sMINUTE = tGCalendar.get(Calendar.MINUTE);
+        if (sMINUTE < 10) {
+            tStringBuffer.append('0');
+        }
+        tStringBuffer.append(sMINUTE);
+        tStringBuffer.append(':');
+        int sSECOND = tGCalendar.get(Calendar.SECOND);
+        if (sSECOND < 10) {
+            tStringBuffer.append('0');
+        }
+        tStringBuffer.append(sSECOND);
+        String tString = tStringBuffer.toString();
+        return tString;
+    }
+
+    /**
+     * 得到以format格式表示的当前时间字符串
+     */
+    public static String getCurrentTime(String format) {
+        SimpleDateFormat t = new SimpleDateFormat(format);
+        return t.format(new Date());
+    }
+
+    /**
+     * 得到以yyyy-MM-dd HH:mm:ss表示的当前时间字符串
+     */
+    public static String getCurrentDateTime() {
+        String format = FORMAT_DATE + " " + FORMAT_TIME;
+        return getCurrentDateTime(format);
+    }
+
+    public static int getDayOfWeek() {
+        Calendar cal = Calendar.getInstance();
+        return cal.get(Calendar.DAY_OF_WEEK);
+    }
+
+    public static int getDayOfWeek(Date date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        return cal.get(Calendar.DAY_OF_WEEK);
+    }
+
+    public static int getDayOfMonth() {
+        Calendar cal = Calendar.getInstance();
+        return cal.get(Calendar.DAY_OF_MONTH);
+    }
+
+    public static int getDayOfMonth(Date date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        return cal.get(Calendar.DAY_OF_MONTH);
+    }
+
+    // 获取某一个月的天数
+    public static int getMaxDayOfMonth(Date date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        return cal.getActualMaximum(Calendar.DATE);
+    }
+
+    // 获取某月的第一天
+    public static String getFirstDayOfMonth(String date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(parse(date));
+        cal.set(Calendar.DAY_OF_MONTH, 1);
+        return SDFD.format(cal.getTime());
+    }
+
+    public static int getDayOfYear() {
+        Calendar cal = Calendar.getInstance();
+        return cal.get(Calendar.DAY_OF_YEAR);
+    }
+
+    public static int getDayOfYear(Date date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        return cal.get(Calendar.DAY_OF_YEAR);
+    }
+
+    public static int getDayOfWeek(String date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(parse(date));
+        return cal.get(Calendar.DAY_OF_WEEK);
+    }
+
+    public static int getDayOfMonth(String date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(parse(date));
+        return cal.get(Calendar.DAY_OF_MONTH);
+    }
+
+    public static int getDayOfYear(String date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(parse(date));
+        return cal.get(Calendar.DAY_OF_YEAR);
+    }
+
+    public static String getCurrentDateTime(String format) {
+        SimpleDateFormat t = new SimpleDateFormat(format);
+        return t.format(new Date());
+    }
+
+    /**
+     * 输出只带日期的字符串
+     */
+    public static String toString(Date date) {
+        if (date == null) {
+            return "";
+        }
+        return SDFD.format(date);
+    }
+
+    /**
+     * 输出带有日期和时间的字符串
+     */
+    public static String toDateTimeString(Date date) {
+        if (date == null) {
+            return "";
+        }
+        return SDFDT.format(date);
+    }
+
+    /**
+     * 按指定的format输出日期字符串
+     */
+    public static String toString(Date date, String format) {
+        SimpleDateFormat t = new SimpleDateFormat(format);
+        return t.format(date);
+    }
+
+    /**
+     * 输出只带时间的字符串
+     */
+    public static String toTimeString(Date date) {
+        if (date == null) {
+            return "";
+        }
+        return SDFDT.format(date);
+    }
+
+    public static int compare(String date1, String date2) {
+        return compare(date1, date2, FORMAT_DATE);
+    }
+
+    public static int compareTime(String time1, String time2) {
+        return compareTime(time1, time2, FORMAT_TIME);
+    }
+
+    public static int compare(String date1, String date2, String format) {
+        Date d1 = parse(date1, format);
+        Date d2 = parse(date2, format);
+        return d1.compareTo(d2);
+    }
+
+    public static int compareTime(String time1, String time2, String format) {
+        String[] arr1 = time1.split(":");
+        String[] arr2 = time2.split(":");
+        if (arr1.length < 2) {
+            throw new RuntimeException("错误的时间值:" + time1);
+        }
+        if (arr2.length < 2) {
+            throw new RuntimeException("错误的时间值:" + time2);
+        }
+        int h1 = Integer.parseInt(arr1[0]);
+        int m1 = Integer.parseInt(arr1[1]);
+        int h2 = Integer.parseInt(arr2[0]);
+        int m2 = Integer.parseInt(arr2[1]);
+        int s1 = 0, s2 = 0;
+        if (arr1.length == 3) {
+            s1 = Integer.parseInt(arr1[2]);
+        }
+        if (arr2.length == 3) {
+            s2 = Integer.parseInt(arr2[2]);
+        }
+        if (h1 < 0 || h1 > 23 || m1 < 0 || m1 > 59 || s1 < 0 || s1 > 59) {
+            throw new RuntimeException("错误的时间值:" + time1);
+        }
+        if (h2 < 0 || h2 > 23 || m2 < 0 || m2 > 59 || s2 < 0 || s2 > 59) {
+            throw new RuntimeException("错误的时间值:" + time2);
+        }
+        if (h1 != h2) {
+            return h1 > h2 ? 1 : -1;
+        } else {
+            if (m1 == m2) {
+                if (s1 == s2) {
+                    return 0;
+                } else {
+                    return s1 > s2 ? 1 : -1;
+                }
+            } else {
+                return m1 > m2 ? 1 : -1;
+            }
+        }
+    }
+
+    public static boolean isTime(String time) {
+        String[] arr = time.split(":");
+        if (arr.length < 2) {
+            return false;
+        }
+        try {
+            int h = Integer.parseInt(arr[0]);
+            int m = Integer.parseInt(arr[1]);
+            int s = 0;
+            if (arr.length == 3) {
+                s = Integer.parseInt(arr[2]);
+            }
+            if (h < 0 || h > 23 || m < 0 || m > 59 || s < 0 || s > 59) {
+                return false;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean isDate(String date) {
+        String[] arr = date.split("-");
+        if (arr.length < 3) {
+            return false;
+        }
+        try {
+            int y = Integer.parseInt(arr[0]);
+            int m = Integer.parseInt(arr[1]);
+            int d = Integer.parseInt(arr[2]);
+            if (y < 0 || m > 12 || m < 0 || d < 0 || d > 31) {
+                return false;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+        return true;
+    }
+
+    public static boolean isWeekend(Date date) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(date);
+        int t = cal.get(Calendar.DAY_OF_WEEK);
+        if (t == Calendar.SATURDAY || t == Calendar.SUNDAY) {
+            return true;
+        }
+        return false;
+    }
+
+    public static boolean isWeekend(String str) {
+        return isWeekend(parse(str));
+    }
+
+    public static Date parse(String str) {
+        if (StringUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            return SDFD.parse(str);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Date parse(String str, String format) {
+        if (StringUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            SimpleDateFormat t = new SimpleDateFormat(format);
+            return t.parse(str);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Date parseDateTime(String str) {
+        if (StringUtils.isEmpty(str)) {
+            return null;
+        }
+        if (str.length() == 10) {
+            return parse(str);
+        }
+        try {
+            return SDFDT.parse(str);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public static Date parseDateTime(String str, String format) {
+        if (StringUtils.isEmpty(str)) {
+            return null;
+        }
+        try {
+            SimpleDateFormat t = new SimpleDateFormat(format);
+            return t.parse(str);
+        } catch (ParseException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    /**
+     * 格式化时间，按照yyyy-MM-dd HH:mm:ss格式
+     * 
+     * @param date
+     *            时间
+     * 
+     * @return String
+     */
+    public static String formatDateTime(Date date) {
+        return SDFDT.format(date);
+    }
+
+    /**
+     * 格式化时间，按照yyyy-MM-dd格式
+     * 
+     * @param date
+     *            时间
+     * 
+     * @return String
+     */
+    public static String formatDate(Date date) {
+        return SDFD.format(date);
+    }
+
+    /**
+     * 日期date上加count分钟，count为负表示减
+     */
+    public static Date addMinute(Date date, int count) {
+        return new Date(date.getTime() + 60000L * count);
+    }
+
+    /**
+     * 日期date上加count妙，count为负表示减
+     */
+    public static Date addSeconds(Date date, int count) {
+        return new Date(date.getTime() + 1000L * count);
+    }
+
+    /**
+     * 日期date上加count小时，count为负表示减
+     */
+    public static Date addHour(Date date, int count) {
+        return new Date(date.getTime() + 3600000L * count);
+    }
+
+    /**
+     * 日期date上加count天，count为负表示减
+     */
+    public static Date addDay(Date date, int count) {
+        return new Date(date.getTime() + 86400000L * count);
+    }
+
+    /**
+     * 日期date上加count星期，count为负表示减
+     */
+    public static Date addWeek(Date date, int count) {
+        Calendar c = Calendar.getInstance();
+        c.setTime(date);
+        c.add(Calendar.WEEK_OF_YEAR, count);
+        return c.getTime();
+    }
+
+    /**
+     * 日期date上加count月，count为负表示减
+     */
+    public static Date addMonth(Date date, int count) {
+        /* ${_ZVING_LICENSE_CODE_} */
+
+        Calendar c = Calendar.getInstance();
+        c.setTime(date);
+        c.add(Calendar.MONTH, count);
+        return c.getTime();
+    }
+
+    /**
+     * 日期date上加count年，count为负表示减
+     */
+    public static Date addYear(Date date, int count) {
+        Calendar c = Calendar.getInstance();
+        c.setTime(date);
+        c.add(Calendar.YEAR, count);
+        return c.getTime();
+    }
+
+    /**
+     * 根据一个日期，返回是星期几的字符串
+     * 
+     * @param date
+     * @return
+     */
+    public static String getWeek(String date) {
+        String[] weeks = { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };
+        Calendar cal = Calendar.getInstance();
+        cal.setTime(parse(date));
+        int week_index = cal.get(Calendar.DAY_OF_WEEK) - 1;
+        if (week_index < 0) {
+            week_index = 0;
+        }
+        return weeks[week_index];
+    }
+
+    /**
+     * 获取一周列表
+     * 
+     * @return List
+     * 
+     */
+    public static List<Map<String, String>> getWeekdayList() {
+        String[] weekday = { "周一", "周二", "周三", "周四", "周五", "周六", "周日" };
+        List<Map<String, String>> weekdayList = new ArrayList<Map<String, String>>();
+        for (int i = 0; i < weekday.length; i++) {
+            Map<String, String> map = new HashMap<String, String>();
+            map.put("name", weekday[i]);
+            map.put("value", String.valueOf(i + 1));
+            map.put("checked", "");
+            weekdayList.add(map);
+        }
+        return weekdayList;
+    }
+
+    /**
+     * 日期返回星期几
+     * 
+     * @param date
+     * 
+     * @return int
+     */
+    public static int dayOfWeek(String date) {
+        try {
+            Calendar c = Calendar.getInstance();
+            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
+            c.setTime(dateFormat.parse(date));
+            int dayOfWeek = c.get(Calendar.DAY_OF_WEEK) - 1;
+            return dayOfWeek == 0 ? 7 : dayOfWeek;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    /**
+     * 取得当前日期是多少周
+     * 
+     * @param date
+     * @return
+     */
+    public static int getWeekOfYear(Date date) {
+        Calendar c = new GregorianCalendar();
+        c.setFirstDayOfWeek(Calendar.MONDAY);
+        c.setMinimalDaysInFirstWeek(7);
+        c.setTime(date);
+
+        return c.get(Calendar.WEEK_OF_YEAR);
+    }
+
+    /**
+     * 得到某年某周的第一天
+     * 
+     * @param year
+     * @param week
+     * @return
+     */
+    public static String getFirstDayOfWeek(int year, int week) {
+        Calendar c = new GregorianCalendar();
+        c.set(Calendar.YEAR, year);
+        c.set(Calendar.MONTH, Calendar.JANUARY);
+        c.set(Calendar.DATE, 1);
+
+        Calendar cal = (GregorianCalendar) c.clone();
+        cal.add(Calendar.DATE, week * 7);
+
+        return formatDate(getFirstDayOfWeek(cal.getTime()));
+    }
+
+    /**
+     * 得到某年某周的最后一天
+     * 
+     * @param year
+     * @param week
+     * @return
+     */
+    public static String getLastDayOfWeek(int year, int week) {
+        Calendar c = new GregorianCalendar();
+        c.set(Calendar.YEAR, year);
+        c.set(Calendar.MONTH, Calendar.JANUARY);
+        c.set(Calendar.DATE, 1);
+
+        Calendar cal = (GregorianCalendar) c.clone();
+        cal.add(Calendar.DATE, week * 7);
+
+        return formatDate(getLastDayOfWeek(cal.getTime()));
+    }
+
+    /**
+     * 取得当前日期所在周的第一天
+     * 
+     * @param date
+     * @return
+     */
+    public static Date getFirstDayOfWeek(Date date) {
+        Calendar c = new GregorianCalendar();
+        c.setFirstDayOfWeek(Calendar.MONDAY);
+        c.setTime(date);
+        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek()); // Monday
+        return c.getTime();
+    }
+
+    /**
+     * 取得当前日期所在周的最后一天
+     * 
+     * @param date
+     * @return
+     */
+    public static Date getLastDayOfWeek(Date date) {
+        Calendar c = new GregorianCalendar();
+        c.setFirstDayOfWeek(Calendar.MONDAY);
+        c.setTime(date);
+        c.set(Calendar.DAY_OF_WEEK, c.getFirstDayOfWeek() + 6); // Sunday
+        return c.getTime();
+    }
+
+    /**
+     * 取得当前月份的第一天
+     * 
+     * @param date
+     * @return
+     */
+    public static String getFirstDayOfMonth(Date date) {
+        Calendar c = new GregorianCalendar();
+        c.setTime(date);
+        c.set(Calendar.DAY_OF_MONTH, 1);
+        return formatDate(c.getTime());
+    }
+
+    /**
+     * 获取N天前的日期
+     * 
+     * @param date
+     *            当前日期 num 几天前
+     * @return
+     * */
+    public static Date getBeginData(Date date, int num) {
+        Calendar c = new GregorianCalendar();
+        c.setTime(date);
+        c.add(Calendar.DATE, -num);
+        return c.getTime();
+    }
+
+    public static int getBetweenDays(Date d1, Date nextD) {
+        Calendar c1 = new GregorianCalendar();
+        c1.setTime(d1);
+        Calendar c2 = new GregorianCalendar();
+        c2.setTime(nextD);
+        return c1.get(Calendar.DAY_OF_YEAR) - c2.get(Calendar.DAY_OF_YEAR);
+    }
+
+    public static int getBetweenMinutes(Date max, Date min) {
+        Calendar c1 = new GregorianCalendar();
+        c1.setTime(max);
+        Calendar c2 = new GregorianCalendar();
+        c2.setTime(min);
+        return (int) ((c1.getTimeInMillis() - c2.getTimeInMillis()) / (1000 * 60));
+    }
+
+    /**
+     * 获取当前年
+     * 
+     * @return
+     */
+    public static int getCurrentYear() {
+        Calendar cal = Calendar.getInstance();
+        int year = cal.get(Calendar.YEAR);
+        return year;
+    }
+
+    /**
+     * 获取当前月
+     * 
+     * @return
+     */
+    public static int getCurrentMonth() {
+        Calendar cal = Calendar.getInstance();
+        int month = cal.get(Calendar.MONTH) + 1;
+        return month;
+    }
+    
+    /**
+     * 把年月日变数字
+     * */
+    public static int getDate(String date){
+    	String [] date1 = date.split("-");
+    	int date2 = Integer.parseInt(date1[0]+date1[1]+date1[2]);
+    	return date2;
+    }
+}

src/main/java/com/dashitech/utils/DecimalUtil.java

@@ -0,0 +1,49 @@
+package com.dashitech.utils;
+
+import java.math.BigDecimal;
+
+
+
+/**
+ * 价格计算工具类
+ */
+public class DecimalUtil {
+	private static final int DIV_SCALE = 50;
+ 
+	/**
+	 * 相加
+	 */
+	public static BigDecimal sum(Object first,Object second) {
+		BigDecimal _first = new BigDecimal(first.toString());
+		BigDecimal _second = new BigDecimal(second.toString());
+		return _first.add(_second);
+	}
+	
+	/**
+	 * 相减
+	 */
+	public static BigDecimal sub(Object first,Object second) {
+		BigDecimal _first = new BigDecimal(first.toString());
+		BigDecimal _second = new BigDecimal(second.toString());
+		return _first.subtract(_second);
+	}
+	
+	/**
+	 * 相乘
+	 */
+	public static BigDecimal ride(Object first,Object second) {
+		BigDecimal _first = new BigDecimal(first.toString());
+		BigDecimal _second = new BigDecimal(second.toString());
+		return _first.multiply(_second);
+    }
+	
+	/**
+	 * 相除
+	 */
+	public static BigDecimal div(Object first,Object second) {
+		BigDecimal _first = new BigDecimal(first.toString());
+		BigDecimal _second = new BigDecimal(second.toString());
+		 return _first.divide(_second,DIV_SCALE,BigDecimal.ROUND_HALF_DOWN);
+	}
+
+}

src/main/java/com/dashitech/utils/FileUtil.java

@@ -0,0 +1,675 @@
+package com.dashitech.utils;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.io.*;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.zip.ZipInputStream;
+
+public class FileUtil {
+	private static Log log = LogFactory.getLog(FileUtil.class);
+	
+	/**
+	 * 根据日期给文件排序，
+	 * @param list
+	 * @param desc true为倒序(最新日期在前面)，false正序
+	 */
+	public static void sortByDate(List<File> list,final boolean desc) {
+		Collections.sort(list, new Comparator<File>() {
+			public int compare(File o1, File o2) {
+				Long a = o1.lastModified();
+				Long b = o2.lastModified();
+				int sort = 0;
+				if(desc) {
+					sort = b.compareTo(a);
+				}else {
+					sort = a.compareTo(b);
+				}
+				return sort;
+			}
+		});
+	}
+
+	/**
+	 * 写文件
+	 * 
+	 * @param f
+	 * @param content
+	 */
+	public static void writeFile(File f, String content) {
+		writeFile(f, content, "utf-8");
+	}
+
+	/**
+	 * 写文件
+	 * 
+	 * @param f
+	 * @param content
+	 */
+	public static void writeFile(File f, String content, String encode) {
+		try {
+			// 如果目录不存在，创建目录
+			File parent = new File(f.getParent());
+			parent.mkdirs();
+
+			if (!f.exists()) {
+				f.createNewFile();
+			}
+			OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(f), encode);
+			BufferedWriter utput = new BufferedWriter(osw);
+			FileOutputStream fo = null;
+			try {
+				fo = new FileOutputStream(f);
+				osw = new OutputStreamWriter(fo, encode);
+				utput = new BufferedWriter(osw);
+				utput.write(content);
+				utput.flush();
+			} catch (IOException ioException) {
+				ioException.printStackTrace();
+			} finally {
+				try {
+					if (fo != null) {
+						fo.close();
+					}
+					if (utput != null) {
+						utput.close();
+					}
+					if (osw != null) {
+						osw.close();
+					}
+				} catch (IOException e) {
+					log.error(e.getMessage(), e);
+				}
+			}
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+		}
+	}
+
+	/**
+	 * 写出url内容为文件
+	 * @param file 写出的文件
+	 * @param url 写出的内容
+	 */
+	public static void writeFileByUrl(String file, String url) {
+		byte[] bytes = null;
+		InputStream in = null;
+		ByteArrayOutputStream bos = null;
+		
+		try {
+			URL resourceUrl = new URL(url);
+			in = (InputStream) resourceUrl.getContent();
+			
+			bos = new ByteArrayOutputStream();
+			byte[] b = new byte[1024];
+			int n;
+			while ((n = in.read(b)) != -1) {
+				bos.write(b, 0, n);
+			}
+			
+			bytes = bos.toByteArray();
+			
+			File f = new File(file);
+			
+			writeFile(f, bytes);
+			
+		} catch (IOException e) {
+			log.error(file+"   "+url);
+			log.error(e.getMessage(),e);
+		} finally {
+			try {
+				if (in != null) {
+					in.close();
+				}
+				if (bos != null) {
+					bos.close();
+				}
+			} catch (IOException e) {
+				log.error(e.getMessage(), e);
+			}
+		}
+	}
+
+	/**
+	 * 写文件
+	 * 
+	 * @param f
+	 * @param bytes
+	 */
+	public static void writeFile(File f, byte[] bytes) {
+		try {
+			// 如果目录不存在，创建目录
+			File parent = new File(f.getParent());
+			parent.mkdirs();
+
+			if (!f.exists()) {
+				f.createNewFile();
+			}
+
+			BufferedOutputStream bos = null;
+			FileOutputStream fo = null;
+			try {
+				fo = new FileOutputStream(f);
+				bos = new BufferedOutputStream(fo);
+				bos.write(bytes);
+				bos.flush();
+			} catch (IOException ioException) {
+				ioException.printStackTrace();
+			} finally {
+				try {
+					if (fo != null) {
+						fo.close();
+					}
+					if (bos != null) {
+						bos.close();
+					}
+				} catch (IOException e) {
+					log.error(e.getMessage(), e);
+				}
+			}
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+		}
+	}
+
+	/**
+	 * 写文件
+	 * 
+	 * @param path
+	 * @param content
+	 */
+	public static void writeFile(String path, String content, String encode) {
+		File f = new File(path);
+		writeFile(f, content, encode);
+	}
+
+	/**
+	 * 写文件
+	 * 
+	 * @param path
+	 * @param content
+	 */
+	public static void writeFile(String path, String content) {
+		File f = new File(path);
+		writeFile(f, content, "utf-8");
+	}
+
+	/**
+	 * 读取文件
+	 * 
+	 * @param file
+	 * @return
+	 */
+	public static String readFile(File file) {
+		return readFile(file, "UTF-8");
+	}
+
+	/**
+	 * 读取文件
+	 * 
+	 * @param file
+	 * @return
+	 */
+	public static String readFile(File file, String encode) {
+		String output = "";
+		InputStreamReader isr = null;
+		BufferedReader input = null;
+
+		if (file.exists()) {
+			if (file.isFile()) {
+				try {
+					isr = new InputStreamReader(new FileInputStream(file), encode);
+					input = new BufferedReader(isr);
+					StringBuffer buffer = new StringBuffer();
+					String text;
+					while ((text = input.readLine()) != null)
+						buffer.append(text + "\n");
+					output = buffer.toString();
+
+				} catch (IOException ioException) {
+					ioException.printStackTrace();
+				} finally {
+					try {
+						if (input != null) {
+							input.close();
+						}
+						if (isr != null) {
+							isr.close();
+						}
+					} catch (IOException e) {
+						log.error(e.getMessage(), e);
+					}
+				}
+			} else if (file.isDirectory()) {
+				throw new RuntimeException(file.getPath() + " isDirectory！");
+			}
+
+		} else {
+			throw new RuntimeException(file.getPath() + " Does not exist！");
+		}
+
+		return output;
+	}
+
+	public static byte[] readFileBytes(File file) {
+		byte[] bytes = null;
+		FileInputStream fis = null;
+		ByteArrayOutputStream bos = null;
+		if (file.exists()) {
+			if (file.isFile()) {
+				try {
+					fis = new FileInputStream(file);
+					bos = new ByteArrayOutputStream();
+					byte[] b = new byte[1024];
+					int n;
+					while ((n = fis.read(b)) != -1) {
+						bos.write(b, 0, n);
+					}
+					fis.close();
+					bos.close();
+					bytes = bos.toByteArray();
+				} catch (IOException ioException) {
+					ioException.printStackTrace();
+				} finally {
+					try {
+						if (fis != null) {
+							fis.close();
+						}
+						if (bos != null) {
+							bos.close();
+						}
+					} catch (IOException e) {
+						log.error(e.getMessage(), e);
+					}
+				}
+			} else if (file.isDirectory()) {
+				throw new RuntimeException(file.getPath() + " isDirectory！");
+			}
+
+		} else {
+			throw new RuntimeException(file.getPath() + " Does not exist！");
+		}
+
+		return bytes;
+	}
+
+	/**
+	 * 读取文件
+	 * 
+	 * @param fileName
+	 * @return
+	 */
+	public static String readFile(String fileName, String encode) {
+		File file = new File(fileName);
+		return readFile(file, encode);
+	}
+
+	/**
+	 * 读取文件
+	 * 
+	 * @param fileName
+	 * @return
+	 */
+	public static String readFile(String fileName) {
+		return readFile(fileName, "utf-8");
+	}
+
+	/**
+	 * 获取目录下所有文件，一级
+	 * 
+	 * @param folder
+	 * @return
+	 */
+	public static List<File> getFiles(String folder) {
+		return getFiles(folder, null);
+	}
+
+	/**
+	 * 获取目录下所有文件，一级，后缀区分
+	 * 
+	 * @param folder
+	 * @return
+	 */
+	public static List<File> getFiles(String folder, String suffix) {
+		File file = new File(folder);
+		List<File> list = new ArrayList<File>();
+		if (file.exists() && file.isDirectory()) {
+			File[] files = file.listFiles();
+			for (File f : files) {
+				String fileName = f.getName();
+				if (suffix == null) {
+					list.add(f);
+				} else if (fileName.endsWith(suffix)) {
+					list.add(f);
+				}
+			}
+		}
+		return list;
+	}
+
+	/**
+	 * 遍历所有文件夹，取出文件
+	 */
+	public static List<File> getFileDeeps(String folder, String suffix) {
+		File file = new File(folder);
+		List<File> list = new ArrayList<File>();
+		if (file.exists() && file.isDirectory()) {
+			File[] files = file.listFiles();
+
+			for (File f : files) {
+				if (f.isFile()) {
+					String fileName = f.getName();
+					if (suffix == null) {
+						list.add(f);
+					} else if (fileName.endsWith(suffix)) {
+						list.add(f);
+					}
+				} else if (f.isDirectory()) {
+					list.addAll(getFileDeeps(f.getAbsolutePath(), suffix));
+				}
+			}
+		}
+		return list;
+	}
+
+	/**
+	 * 遍历所有文件夹，取出文件
+	 */
+	public static List<File> getFileDeeps(String folder, List<String> suffixs) {
+		File file = new File(folder);
+		List<File> list = new ArrayList<File>();
+		if (file.exists() && file.isDirectory()) {
+			File[] files = file.listFiles();
+
+			for (File f : files) {
+				if (f.isFile()) {
+					String fileName = f.getName();
+					for (String suffix : suffixs) {
+						if (suffix == null) {
+							list.add(f);
+						} else if (fileName.toLowerCase().endsWith(suffix)) {
+							list.add(f);
+						}
+					}
+				} else if (f.isDirectory()) {
+					list.addAll(getFileDeeps(f.getAbsolutePath(), suffixs));
+				}
+			}
+		}
+		return list;
+	}
+
+	/**
+	 * 获取目录下所有文件夹，一级
+	 * 
+	 * @param folder
+	 * @return
+	 */
+	public static List<File> getFolders(String folder) {
+		File file = new File(folder);
+		List<File> files = new ArrayList<File>();
+		if (file.exists()) {
+			File[] sonFiles = file.listFiles();
+			if (sonFiles != null && sonFiles.length > 0) {
+				for (int i = 0; i < sonFiles.length; i++) {
+					if (sonFiles[i].isDirectory()) {
+						files.add(sonFiles[i]);
+					}
+				}
+			}
+		}
+		return files;
+	}
+
+	/**
+	 * 判断是否有子目录
+	 * 
+	 * @param folder
+	 * @return
+	 */
+	public static boolean hasSonFolder(String folder) {
+		File file = new File(folder);
+		return hasSonFolder(file);
+	}
+
+	/**
+	 * 判断是否有子目录
+	 * 
+	 * @param file
+	 * @return
+	 */
+	public static boolean hasSonFolder(File file) {
+		if (file.exists()) {
+			File[] sonFiles = file.listFiles();
+			if (sonFiles != null && sonFiles.length > 0) {
+				for (int i = 0; i < sonFiles.length; i++) {
+					if (sonFiles[i].isDirectory()) {
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * 创建目录
+	 * 
+	 * @param folder
+	 */
+	public static void mkdirs(String folder) {
+		File file = new File(folder);
+		if (!file.exists()) {
+			file.mkdirs();
+		}
+	}
+
+	/**
+	 * 复制文件
+	 * 
+	 * @param src
+	 * @param dst
+	 */
+	public static void copy(File src, File dst) {
+		try {
+			// 如果是文件夹，并且已存在则什么都不做
+			if (dst.isDirectory() && dst.exists()) {
+				return;
+			}
+			if (!dst.getParentFile().exists()) {
+				dst.getParentFile().mkdirs();
+			}
+
+			int BUFFER_SIZE = 32 * 1024;
+			InputStream in = null;
+			OutputStream out = null;
+			try {
+				in = new FileInputStream(src);
+				out = new FileOutputStream(dst);
+				byte[] buffer = new byte[BUFFER_SIZE];
+				int count;
+				while ((count = in.read(buffer)) != -1) {
+					out.write(buffer, 0, count);
+				}
+				out.flush();
+			} catch (Exception e) {
+				log.error(src.getAbsolutePath() + "," + dst.getAbsolutePath() + ";" + e.getMessage(), e);
+			} finally {
+				if (null != in) {
+					in.close();
+				}
+				if (null != out) {
+					out.close();
+				}
+			}
+		} catch (Exception e2) {
+			log.error(e2.getMessage(), e2);
+		}
+	}
+
+	/**
+	 * 复制文件夹，包含内容，如果已有覆盖已有文件
+	 * 
+	 * @param overwrite
+	 *            是否覆盖文件
+	 */
+	public static void copyDirectiory(String sourceDir, String targetDir, boolean overwrite) throws IOException {
+		if (new File(sourceDir).exists()) {
+			// 新建目标目录
+			File targetFolder = new File(targetDir);
+			if (!targetFolder.exists()) {
+				targetFolder.mkdirs();
+			}
+			// 获取源文件夹当前下的文件或目录
+			File[] file = (new File(sourceDir)).listFiles();
+			for (int i = 0; i < file.length; i++) {
+
+				try {
+					if (file[i].isFile()) {
+						// 源文件
+						File sourceFile = file[i];
+						// 目标文件
+						File targetFile = new File(new File(targetDir).getAbsolutePath() + File.separator + file[i].getName());
+
+						// 如果重写为true，直接覆盖现有文件
+						if (overwrite) {
+							copy(sourceFile, targetFile);
+						} else if (!targetFile.exists()) {
+							// 如果文件不存在才写文件
+							copy(sourceFile, targetFile);
+						}
+
+					}
+					if (file[i].isDirectory()) {
+						// 准备复制的源文件夹
+						String dir1 = sourceDir + "/" + file[i].getName();
+						// 准备复制的目标文件夹
+						String dir2 = targetDir + "/" + file[i].getName();
+						File fileDir2 = new File(targetDir);
+						if (!fileDir2.exists()) {
+							fileDir2.mkdirs();
+						}
+						copyDirectiory(dir1, dir2, overwrite);
+					}
+				} catch (Exception e) {
+					log.error(e.getMessage(), e);
+				}
+
+			}
+		}
+	}
+
+	/**
+	 * 获取扩展名 .jpg
+	 */
+	public static String getExt(File src) {
+		if (src != null) {
+			String name = src.getName();
+			return name.substring(name.lastIndexOf("."), name.length());
+		}
+		return "";
+	}
+
+	/**
+	 * 获取扩展名 .jpg
+	 */
+	public static String getExt(String src) {
+		if (src != null) {
+			return src.substring(src.lastIndexOf("."), src.length());
+		}
+		return "";
+	}
+
+	/**
+	 * 删除指定文件
+	 * 
+	 * @param path
+	 */
+	public static void del(String path) {
+		File file = new File(path);
+		deleteFile(file);
+	}
+
+	/**
+	 * 递归删除文件夹下所有文件
+	 * 
+	 * @param file
+	 */
+	public static void deleteFile(File file) {
+		if (file.exists() && file.canRead()) { // 判断文件是否存在
+			try {
+				if (file.isFile()) { // 判断是否是文件
+					file.delete(); // delete()方法 你应该知道 是删除的意思;
+				} else if (file.isDirectory()) { // 否则如果它是一个目录
+					File files[] = file.listFiles(); // 声明目录下所有的文件 files[];
+					for (int i = 0; i < files.length; i++) { // 遍历目录下所有的文件
+						deleteFile(files[i]); // 把每个文件 用这个方法进行迭代
+					}
+				}
+				file.delete();
+			} catch (Exception e) {
+				log.error(e.getMessage(), e);
+			}
+		}
+	}
+
+	public static void deleteFile(List<File> files) {
+		for (File f : files) {
+			deleteFile(f);
+		}
+	}
+
+
+
+	/**
+	 * 解压缩
+	 * 
+	 * @param sZipPathFile
+	 *            要解压的文件
+	 * @param sDestPath
+	 *            解压到某文件夹
+	 * @return
+	 */
+	public static List<String> unzip(String sZipPathFile, String sDestPath) {
+		List<String> allFileName = new ArrayList<String>();
+		try {
+			// 先指定压缩档的位置和档名，建立FileInputStream对象
+			FileInputStream fins = new FileInputStream(sZipPathFile);
+			// 将fins传入ZipInputStream中
+			ZipInputStream zins = new ZipInputStream(fins);
+			java.util.zip.ZipEntry ze = null;
+			byte[] ch = new byte[256];
+			while ((ze = zins.getNextEntry()) != null) {
+				File zfile = new File(sDestPath + ze.getName());
+				File fpath = new File(zfile.getParentFile().getPath());
+				if (ze.isDirectory()) {
+					if (!zfile.exists())
+						zfile.mkdirs();
+					zins.closeEntry();
+				} else {
+					if (!fpath.exists())
+						fpath.mkdirs();
+					FileOutputStream fouts = new FileOutputStream(zfile);
+					int i;
+					allFileName.add(zfile.getAbsolutePath());
+					while ((i = zins.read(ch)) != -1)
+						fouts.write(ch, 0, i);
+					zins.closeEntry();
+					fouts.close();
+				}
+			}
+			fins.close();
+			zins.close();
+		} catch (Exception e) {
+			log.error(e.getMessage(), e);
+		}
+		return allFileName;
+	}
+
+
+}

src/main/java/com/dashitech/utils/HttpUtil.java

@@ -0,0 +1,372 @@
+package com.dashitech.utils;
+
+import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang.StringUtils;
+import org.apache.http.HttpEntity;
+import org.apache.http.NameValuePair;
+import org.apache.http.client.config.RequestConfig;
+import org.apache.http.client.entity.UrlEncodedFormEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.util.EntityUtils;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.SocketException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class HttpUtil {
+
+    public static CloseableHttpClient getHttpClient() {
+    	 RequestConfig config = RequestConfig.custom().setConnectTimeout(60000).setSocketTimeout(15000).build();
+    	 CloseableHttpClient httpClient = HttpClientBuilder.create().setDefaultRequestConfig(config).build();
+         return httpClient;
+    }
+
+    /**
+     * HTTP Get 获取内容
+     * @param url  请求的url地址 ?之前的地址
+     * @param params	请求的参数
+     * @param charset	编码格式
+     * @return	页面内容
+     */
+    public static String doGet(String url,Map<String,String> params,String charset){
+    	if(StringUtils.isBlank(url)){
+    		return null;
+    	}
+    	try {
+    		if(params != null && !params.isEmpty()){
+    			List<NameValuePair> pairs = new ArrayList<NameValuePair>(params.size());
+    			for(Map.Entry<String,String> entry : params.entrySet()){
+    				String value = entry.getValue();
+    				if(value != null){
+    					pairs.add(new BasicNameValuePair(entry.getKey(),value));
+    				}
+    			}
+    			url += "?" + EntityUtils.toString(new UrlEncodedFormEntity(pairs, charset));
+    		}
+    		HttpGet httpGet = new HttpGet(url);
+    		CloseableHttpResponse response = getHttpClient().execute(httpGet);
+    		int statusCode = response.getStatusLine().getStatusCode();
+    		if (statusCode != 200) {
+    			httpGet.abort();
+    			throw new RuntimeException("HttpClient,error status code :" + statusCode);
+    		}
+    		HttpEntity entity = response.getEntity();
+    		String result = null;
+    		if (entity != null){
+    			result = EntityUtils.toString(entity, charset);
+    		}
+    		EntityUtils.consume(entity);
+    		response.close();
+    		return result;
+    	} catch (Exception e) {
+    		e.printStackTrace();
+    	}
+    	return null;
+    }
+    
+    /**
+     * HTTP Post 获取内容
+     * @param url  请求的url地址 ?之前的地址
+     * @param params	请求的参数
+     * @param charset	编码格式
+     * @return	页面内容
+     */
+    public static String doPost(String url,Map<String,String> params,String charset){
+    	if(StringUtils.isBlank(url)){
+    		return null;
+    	}
+    	try {
+    		List<NameValuePair> pairs = null;
+    		if(params != null && !params.isEmpty()){
+    			pairs = new ArrayList<NameValuePair>(params.size());
+    			for(Map.Entry<String,String> entry : params.entrySet()){
+    				String value = entry.getValue();
+    				if(value != null){
+    					pairs.add(new BasicNameValuePair(entry.getKey(),value));
+    				}
+    			}
+    		}
+    		HttpPost httpPost = new HttpPost(url);
+    		if(pairs != null && pairs.size() > 0){
+    			httpPost.setEntity(new UrlEncodedFormEntity(pairs,charset));
+    		}
+    		CloseableHttpResponse response = getHttpClient().execute(httpPost);
+    		int statusCode = response.getStatusLine().getStatusCode();
+    		if (statusCode != 200) {
+    			httpPost.abort();
+    			throw new RuntimeException("HttpClient,error status code :" + statusCode);
+    		}
+    		HttpEntity entity = response.getEntity();
+    		String result = null;
+    		if (entity != null){
+    			result = EntityUtils.toString(entity, charset);
+    		}
+    		EntityUtils.consume(entity);
+    		response.close();
+    		return result;
+    	} catch (Exception e) {
+    		e.printStackTrace();
+    	}
+    	return null;
+    }
+
+	public static void outPrint(HttpServletResponse response, String content, String charset) {
+		response.setCharacterEncoding(charset);
+		response.setContentType(new StringBuilder().append("text/html;charset=").append(charset).toString());
+		PrintWriter out = null;
+		try {
+			out = response.getWriter();
+			out.println(content);
+			out.flush();
+		} catch (Exception e) {
+			e.printStackTrace();
+		} finally {
+			out.close();
+		}
+	}
+	
+	public static String readResponse(String requestUrl, Map<String, String> params, String method, String charset) {
+		StringBuffer sb = new StringBuffer();
+		String paramsStr = "";
+		if ((params != null) && (params.size() > 0)) {
+			for (Map.Entry e : params.entrySet()) {
+				sb.append((String) e.getKey());
+				sb.append("=");
+				sb.append((String) e.getValue());
+				sb.append("&");
+			}
+			paramsStr = sb.substring(0, sb.length() - 1);
+		}
+		return readResponse(requestUrl, paramsStr, method, charset);
+	}
+	
+	public static String readPostResponse(String requestUrl, String json, String contentType) {
+		HttpURLConnection conn = null;
+		OutputStreamWriter out = null;
+		BufferedReader in = null;
+		String line = null;
+		try {
+			URL url = new URL(requestUrl);
+			conn = (HttpURLConnection) url.openConnection();
+			conn.setRequestMethod("POST");
+			conn.setRequestProperty("Content-Type", contentType);
+			conn.setRequestProperty("Accept-Charset", "UTF-8");
+			conn.setRequestProperty("Content-Length", new StringBuilder().append("").append(json.length()).toString());
+			conn.setUseCaches(false);
+			conn.setDoOutput(true);
+			out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
+			out.write(json);
+			out.flush();
+			out.close();
+
+			if (conn.getResponseCode() != 200) {
+				System.err.println("connect failed!" + conn.getResponseCode());
+				String str1 = "";
+				return str1;
+			}
+			String result = "";
+			in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
+			while ((line = in.readLine()) != null) {
+				result = new StringBuilder().append(result).append(line).append("\n").toString();
+			}
+			String str2 = result;
+			return str2;
+		} catch (SocketException se) {
+			se.printStackTrace();
+			line = null;
+			return line;
+		} catch (Exception e) {
+			e.printStackTrace();
+			line = null;
+			return line;
+		} finally {
+			if (out != null) {
+				try {
+					out.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (in != null) {
+				try {
+					in.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (conn != null)
+				conn.disconnect();
+		}
+	}
+	
+	public static String readResponse(String requestUrl, String requestData, String method, String charset) {
+		HttpURLConnection conn = null;
+		OutputStreamWriter out = null;
+		BufferedReader in = null;
+		String line = null;
+		try {
+			URL url = new URL(requestUrl);
+			conn = (HttpURLConnection) url.openConnection();
+			conn.setRequestMethod(method);
+			conn.setRequestProperty("Content-Type", "text/html");
+			conn.setRequestProperty("Accept-Charset", charset);
+			conn.setUseCaches(false);
+			conn.setDoOutput(true);
+			conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
+			conn.setRequestProperty("Content-Length", new StringBuilder().append("").append(requestData.length()).toString());
+			out = new OutputStreamWriter(conn.getOutputStream(), charset);
+			out.write(requestData);
+			out.flush();
+			out.close();
+
+			if (conn.getResponseCode() != 200) {
+				System.err.println("connect failed!" + conn.getResponseCode());
+				String str1 = "";
+				return str1;
+			}
+			String result = "";
+			in = new BufferedReader(new InputStreamReader(conn.getInputStream(), charset));
+			while ((line = in.readLine()) != null) {
+				result = new StringBuilder().append(result).append(line).append("\n").toString();
+			}
+			String str2 = result;
+			return str2;
+		} catch (SocketException se) {
+			se.printStackTrace();
+			line = null;
+			return line;
+		} catch (Exception e) {
+			e.printStackTrace();
+			line = null;
+			return line;
+		} finally {
+			if (out != null) {
+				try {
+					out.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (in != null) {
+				try {
+					in.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (conn != null)
+				conn.disconnect();
+		}
+	}
+
+	public static String getString(byte[] b, int offset, int len, String encoding) {
+		try {
+			return new String(b, offset, len, encoding);
+		} catch (UnsupportedEncodingException e) {
+		}
+		return new String(b, offset, len);
+	}
+
+
+	public static String doPost(String httpUrl,Object param) {
+
+		HttpURLConnection connection = null;
+		InputStream is = null;
+		OutputStream out = null;
+		BufferedReader br = null;
+		String result = null;
+		try {
+			URL url = new URL(httpUrl);
+			// 通过远程url连接对象打开连接
+			connection = (HttpURLConnection) url.openConnection();
+			// 设置连接请求方式
+			connection.setRequestMethod("POST");
+			// 设置连接主机服务器超时时间：15000毫秒
+			connection.setConnectTimeout(15000);
+			// 设置读取主机服务器返回数据超时时间：60000毫秒
+			connection.setReadTimeout(60000);
+
+			// 默认值为：false，当向远程服务器传送数据/写数据时，需要设置为true
+			connection.setDoOutput(true);
+			// 默认值为：true，当前向远程服务读取数据时，设置为true，该参数可有可无
+			connection.setDoInput(true);
+			// 设置传入参数的格式:请求参数应该是 name1=value1&name2=value2 的形式。
+			connection.setRequestProperty("Content-Type", "application/json");
+			// 设置鉴权信息：Authorization: Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0
+			//connection.setRequestProperty("Authorization", "Bearer da3efcbf-0845-4fe3-8aba-ee040be542c0");
+			// 通过连接对象获取一个输出流
+			out = connection.getOutputStream();
+			// 通过输出流对象将参数写出去/传输出去,它是通过字节数组写出的
+			//os.write(param.getBytes());
+			//JSONObject obj = new JSONObject();
+			// java.net.URLEncoder.encode 编码之后会有%多余%的问题，在传输的过程中无法被解析
+			// String json = java.net.URLEncoder.encode(obj.toString(), "utf-8");
+			Object o = JSONObject.toJSON(param);
+			Object jsonObject = JSONObject.parse(o.toString());
+			out.write(jsonObject.toString().getBytes());
+
+
+			// 通过连接对象获取一个输入流，向远程读取
+			if (connection.getResponseCode() == 200) {
+
+				is = connection.getInputStream();
+				// 对输入流对象进行包装:charset根据工作项目组的要求来设置
+				br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
+
+				StringBuffer sbf = new StringBuffer();
+				String temp = null;
+				// 循环遍历一行一行读取数据
+				while ((temp = br.readLine()) != null) {
+					sbf.append(temp);
+					sbf.append("\r\n");
+				}
+				result = sbf.toString();
+			}
+		} catch (MalformedURLException e) {
+			e.printStackTrace();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} finally {
+			// 关闭资源
+			if (null != br) {
+				try {
+					br.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (null != out) {
+				try {
+					out.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			if (null != is) {
+				try {
+					is.close();
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+			}
+			// 断开与远程地址url的连接
+			connection.disconnect();
+		}
+		return result;
+	}
+	public static void main(String[] args) {
+		String re=readResponse("www.baidu.com","","get","UTF-8");
+		System.out.println(re);
+	}
+}

src/main/java/com/dashitech/utils/I18n.java

@@ -0,0 +1,20 @@
+package com.dashitech.utils;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+/**
+ * Created by chi on 2019/9/10.
+ * 实体说明注解
+ */
+
+
+@Target(FIELD)
+@Retention(RUNTIME)
+@Documented
+public @interface I18n {
+    String value();
+}

src/main/java/com/dashitech/utils/JDBCLearn.java

@@ -0,0 +1,81 @@
+package com.dashitech.utils;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by xuweihua on 2021/6/9.
+ */
+public class JDBCLearn {
+    private static String jdbc = PropertiesUtil.getProperty("sqlserver.conn.jdbc");
+    private static String user = PropertiesUtil.getProperty("sqlserver.user");
+    private static String pwd = PropertiesUtil.getProperty("sqlserver.password");
+
+    private static String jdbc1 = PropertiesUtil.getProperty("sqlserver.conn.jdbc1");
+    private static String user1 = PropertiesUtil.getProperty("sqlserver.user1");
+    private static String pwd1 = PropertiesUtil.getProperty("sqlserver.password1");
+
+    /**
+    public static void main(String[] args) throws ClassNotFoundException, SQLException { //加载驱动
+        Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
+        String url = "jdbc:sqlserver://172.18.100.200:1433;DataBaseName=CR_JMPZZX_V4";
+        String username = "dszzzxroot";
+        String passWord = "IuMrNP01Gk7NFeFz";
+        //建立连接
+        Connection comm = DriverManager.getConnection(url,username,passWord);
+        String SQL = "SELECT * FROM dbo.JMPZ_ZZFW_JJD_V ";//注意：表名一定要带[]
+        Statement stmt = comm.createStatement();
+        //结果集
+        ResultSet rs = stmt.executeQuery(SQL);
+        List list = new ArrayList();
+        ResultSetMetaData rsmd = rs.getMetaData();
+        //每循环一次遍历出来1条记录，记录对应的所有列值存放在map中(columnName:columnValue)
+        while(rs.next()){
+            Map map = new HashMap();
+            int columnCount = rsmd.getColumnCount();
+            for(int i=0;i<columnCount;i++){
+                String columnName = rsmd.getColumnName(i+1);
+                map.put(columnName, rs.getObject(i+1));
+            }
+            list.add(map);
+        }
+        rs.close();
+        comm.close();
+    }
+    */
+    public List getDataList(String sql,Integer type){
+        try{
+            //建立连接
+            Connection comm = null;
+            if (type == null) {
+                comm = DriverManager.getConnection(jdbc, user, pwd);
+            } else if (type != null && type == 1) {
+                comm = DriverManager.getConnection(jdbc1, user1, pwd1);
+            }
+            Statement stmt = comm.createStatement();
+            //结果集
+            ResultSet rs = stmt.executeQuery(sql);
+            List list = new ArrayList();
+            ResultSetMetaData rsmd = rs.getMetaData();
+            //每循环一次遍历出来1条记录，记录对应的所有列值存放在map中(columnName:columnValue)
+            while(rs.next()){
+                Map map = new HashMap();
+                int columnCount = rsmd.getColumnCount();
+                for(int i=0;i<columnCount;i++){
+                    String columnName = rsmd.getColumnName(i+1);
+                    map.put(columnName, rs.getObject(i+1));
+                }
+                list.add(map);
+            }
+            rs.close();
+            comm.close();
+            return list;
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        return  null;
+    }
+}

src/main/java/com/dashitech/utils/JsonParam.java

@@ -0,0 +1,120 @@
+package com.dashitech.utils;
+
+import net.sf.json.JSONArray;
+import net.sf.json.JSONObject;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+public class JsonParam implements Serializable {
+
+	private static final long serialVersionUID = -4882852696761401880L;
+
+	private Integer total;
+
+	private Integer pageIndex = 1;
+
+	private Integer pageSize = 20;
+
+	private Integer totalPage = 0;
+
+	/**
+	 * 实体bean
+	 */
+	private Map<String, Object> model;
+	/**
+	 * 实体bean列表
+	 */
+	private List<Map<String,Object>> list;
+	/**
+	 * 其他参数
+	 */
+	private Map<String, Object> param;
+	
+	
+	
+	public Integer getTotal() {
+		return total;
+	}
+
+	public void setTotal(Integer total) {
+		this.total = total;
+	}
+
+	public Integer getPageIndex() {
+		return pageIndex;
+	}
+
+	public void setPageIndex(Integer pageIndex) {
+		this.pageIndex = pageIndex;
+	}
+
+	public Integer getPageSize() {
+		return pageSize;
+	}
+
+	public void setPageSize(Integer pageSize) {
+		this.pageSize = pageSize;
+	}
+
+	public Integer getTotalPage() {
+		return totalPage;
+	}
+
+	public void setTotalPage(Integer totalPage) {
+		this.totalPage = totalPage;
+	}
+
+	public Map<String, Object> getModel() {
+		return model;
+	}
+
+	public void setModel(Map<String, Object> model) {
+		this.model = model;
+	}
+
+	public Map<String, Object> getParam() {
+		return param;
+	}
+
+	public void setParam(Map<String, Object> param) {
+		this.param = param;
+	}
+	
+	public List<Map<String, Object>> getList() {
+		return list;
+	}
+
+	public void setList(List<Map<String, Object>> list) {
+		this.list = list;
+	}
+
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public <T> T getModelBean(Class clazz) {
+		JSONObject jsonObj = JsonUtil.toJSONObject(getModel());
+		Object temp = JsonUtil.toObject(jsonObj.toString(), clazz);
+		if(temp != null) {
+			return (T)temp;
+		}
+		return null;
+	}
+	
+	@SuppressWarnings({ "rawtypes", "unchecked" })
+	public <T> List<T> getModelListBean(Class clazz) {
+		JSONArray jsonArr = JsonUtil.toJSONArray(getList());
+		List<T> temp = JsonUtil.toList2(jsonArr.toString(), clazz);
+		if(temp != null) {
+			return temp;
+		}
+		return new ArrayList<T>();
+	}
+
+	@Override
+	public String toString() {
+		return "JsonParamBean [total=" + total + ", pageIndex=" + pageIndex + ", pageSize=" + pageSize + ", totalPage=" + totalPage + ", model=" + model + ", list=" + list + ", param=" + param + "]";
+	}
+
+}

src/main/java/com/dashitech/utils/JsonResponse.java

@@ -0,0 +1,100 @@
+package com.dashitech.utils;
+
+import java.io.Serializable;
+
+
+import net.sf.json.JSONObject;
+
+public class JsonResponse implements Serializable{
+	private static final long serialVersionUID = 2275655193720587417L;
+	
+	/**
+	 * 消息
+	 */
+	private String msg;
+	/**
+	 * 状态
+	 */
+	private Integer status;
+	/**
+	 * 数据
+	 */
+	private Object data;
+	
+	public String getMsg() {
+		return msg;
+	}
+
+	public void setMsg(String msg) {
+		this.msg = msg;
+	}
+
+	public Integer getStatus() {
+		return status;
+	}
+
+	public void setStatus(Integer status) {
+		this.status = status;
+	}
+
+	public Object getData() {
+		return data;
+	}
+
+	public void setData(Object data) {
+		this.data = data;
+	}
+
+	public JsonResponse() {
+		
+	}
+	
+	public JsonResponse(String msg, Integer status, Object data) {
+		super();
+		this.msg = msg;
+		this.status = status;
+		this.data = data;
+	}
+	
+	public static JsonResponse success(Object data) {
+		JsonResponse bean = new JsonResponse();
+		bean.setData(data);
+		bean.setMsg("成功！");
+		bean.setStatus(200);
+		return bean;
+	}
+	
+	public static JsonResponse error(String msg) {
+		JsonResponse bean = new JsonResponse();
+		bean.setMsg("服务出错！");
+		bean.setStatus(500);
+		return bean;
+	}
+	
+	public static JsonResponse forbidden() {
+		JsonResponse bean = new JsonResponse();
+		bean.setMsg("没有权限！");
+		bean.setStatus(403);
+		return bean;
+	}
+	
+	public static JsonResponse forbidden(String msg) {
+		JsonResponse bean = new JsonResponse();
+		bean.setMsg(msg);
+		bean.setStatus(403);
+		return bean;
+	}
+
+	@Override
+	public String toString() {
+		try {
+			JSONObject json = JsonUtil.toJSONObject(this);
+			return json.toString();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return error("json转换错误！").toString();
+	}
+	
+	
+}

src/main/java/com/dashitech/utils/JsonUtil.java

@@ -0,0 +1,163 @@
+package com.dashitech.utils;
+
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.JavaType;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import net.sf.json.JSONArray;
+import net.sf.json.JSONObject;
+import net.sf.json.JsonConfig;
+import net.sf.json.processors.JsonValueProcessor;
+import net.sf.json.util.CycleDetectionStrategy;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+
+public class JsonUtil {
+
+    public static JSONObject toJSONObject(Object obj) {
+        return JSONObject.fromObject(obj, getJsonConfig());
+    }
+
+    public static String toJsonString(Object obj) {
+        com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+        mapper.setDateFormat(DateUtil.SDF_DATETIME);
+        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
+        try {
+            return mapper.writeValueAsString(obj);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return "";
+    }
+
+    public static JSONArray toJSONArray(Object obj) {
+        return JSONArray.fromObject(obj, getJsonConfig());
+    }
+
+    public static <T> List<T> toList(Object obj, Class<T> clazz) {
+        JSONArray arr = toJSONArray(obj);
+        @SuppressWarnings({"unchecked", "deprecation"}) List<T> list = JSONArray.toList(arr, clazz);
+        return list;
+    }
+
+    public static <T> List<T> toList(Object obj, Class<T> clazz, Map classMap) {
+        JSONArray arr = toJSONArray(obj);
+        @SuppressWarnings({"unchecked", "deprecation"}) List<T> list = JSONArray.toList(arr, clazz, classMap);
+        return list;
+    }
+
+    /**
+     * 会格式化日期为yyyy-MM-dd HH:mm:ss
+     */
+    @SuppressWarnings({"deprecation"})
+    public static <T> List<T> toList2(String json, Class<T> clazz) {
+        try {
+            com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+            mapper.setDateFormat(DateUtil.SDF_DATETIME);
+            mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+            mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+
+            JavaType javaType = mapper.getTypeFactory().constructParametricType(ArrayList.class, clazz);
+            List<T> result = mapper.readValue(json, javaType);
+            return result;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * 2016-03-01 00:00:00 替换为 2016-03-01 <br/>
+     * 如果报错返回原始数据
+     */
+    public static JSONObject replaceDateTime(JSONObject source) {
+        JSONObject result = source;
+        try {
+            String ss = source.toString();
+            String formatJson = ss.replaceAll(" \\d{2}:\\d{2}:\\d{2}", "");
+            result = JSONObject.fromObject(formatJson);
+        } catch (Exception e) {
+        }
+        return result;
+    }
+
+
+    public static <T> T toObject(String json, Class<T> valueType) {
+        com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+        mapper.setDateFormat(DateUtil.SDF_DATETIME);
+        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
+
+        try {
+            return mapper.readValue(json, valueType);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static <T> List<T> toListObject(String json, Class<T> valueType) {
+        com.fasterxml.jackson.databind.ObjectMapper mapper = new com.fasterxml.jackson.databind.ObjectMapper();
+        mapper.setDateFormat(DateUtil.SDF_DATETIME);
+        mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
+        mapper.configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true);
+
+        try {
+            List<T> result = new ArrayList<>();
+            List<Map> list = mapper.readValue(json, ArrayList.class);
+            for (Map map : list) {
+                T t = toObject(toJSONObject(map).toString(), valueType);
+                result.add(t);
+            }
+            return result;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static JsonConfig getJsonConfig() {
+        JsonConfig config = new JsonConfig();
+        //去掉class
+        config.setIgnoreDefaultExcludes(false);
+        //禁止自包含
+        config.setCycleDetectionStrategy(CycleDetectionStrategy.LENIENT);
+        //处理日期转换
+        config.registerJsonValueProcessor(Date.class, new Date_JsonValueProcessor());
+        return config;
+    }
+
+}
+
+class Date_JsonValueProcessor implements JsonValueProcessor {
+
+    public Object processArrayValue(Object value, JsonConfig config) {
+        return process(value, config);
+    }
+
+    public Object processObjectValue(String key, Object value, JsonConfig config) {
+        return process(value, config);
+    }
+
+    ;
+
+    private Object process(Object value, JsonConfig config) {
+        if (value == null) {
+            return "";
+        }
+        if (value instanceof Date) {
+            String date = DateUtil.SDF_DATETIME.format((Date) value);
+            return date;
+        } else {
+            return value == null ? null : value.toString();
+        }
+    }
+
+}

src/main/java/com/dashitech/utils/MyObjectMapper.java

@@ -0,0 +1,17 @@
+package com.dashitech.utils;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+
+
+
+public class MyObjectMapper extends ObjectMapper{
+	
+	private static final long serialVersionUID = 1L;
+
+	public MyObjectMapper() {
+		this.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);
+		this.setDateFormat(new MyObjectMapperDateFormat());
+	}
+
+}

src/main/java/com/dashitech/utils/MyObjectMapperDateFormat.java

@@ -0,0 +1,119 @@
+package com.dashitech.utils;
+
+import java.text.FieldPosition;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.commons.lang.StringUtils;
+
+public class MyObjectMapperDateFormat extends SimpleDateFormat{
+	private static final long serialVersionUID = 1L;
+	public static final String Y_M_D = "yyyy-MM-dd";  
+    public static final String Y_M_D_HM = "yyyy-MM-dd HH:mm";  
+    public static final String Y_M_D_HMS = "yyyy-MM-dd HH:mm:ss";  
+    public static final String YMD = "yyyyMMdd";  
+    public static final String YMDHM = "yyyyMMddHHmm";  
+    public static final String YMDHMS = "yyyyMMddHHmmss";  
+    public static final String ymd = "yyyy/MM/dd";  
+    public static final String ymd_HM = "yyyy/MM/dd HH:mm";  
+    public static final String ymd_HMS = "yyyy/MM/dd HH:mm:ss";  
+	
+	@Override  
+    public StringBuffer format(Date date, StringBuffer toAppendTo, FieldPosition pos) {  
+        return new StringBuffer(smartFormat(date));  
+    }  
+  
+    @Override  
+    public Date parse(String text) throws ParseException {  
+        return smartFormat(text);  
+    }  
+    
+    public static String smartFormat(Date date) {  
+        String dateStr = null;  
+        if (date == null) {  
+            dateStr = "";  
+        } else {  
+            try {  
+                dateStr = formatDate(date, Y_M_D_HMS);  
+                //时分秒  
+                if (dateStr.endsWith(" 00:00:00")) {  
+                    dateStr = dateStr.substring(0, 10);  
+                }  
+                //时分  
+                else if (dateStr.endsWith("00:00")) {  
+                    dateStr = dateStr.substring(0, 16);  
+                }  
+                //秒  
+                else if (dateStr.endsWith(":00")) {  
+                    dateStr = dateStr.substring(0, 16);  
+                }  
+            } catch (Exception ex) {  
+                throw new IllegalArgumentException("转换日期失败: " + ex.getMessage(), ex);  
+            }  
+        }  
+        return dateStr;  
+    }  
+  
+    /** 
+     * 智能转换日期 
+     * 
+     * @param text 
+     * @return 
+     */  
+    public static Date smartFormat(String text) {  
+        Date date = null;  
+        try {  
+            if (text == null || text.length() == 0) {  
+                date = null;  
+            } else if (text.length() == 10) {  
+                date = formatStringToDate(text, Y_M_D);  
+            } else if (text.length() == 13) {  
+                date = new Date(Long.parseLong(text));  
+            } else if (text.length() == 16) {  
+                date = formatStringToDate(text, Y_M_D_HM);  
+            } else if (text.length() == 19) {  
+                date = formatStringToDate(text, Y_M_D_HMS);  
+            } else {  
+                throw new IllegalArgumentException("日期长度不符合要求!");  
+            }  
+        } catch (Exception e) {  
+            throw new IllegalArgumentException("日期转换失败!");  
+        }  
+        return date;  
+    }  
+    
+    public static String formatDate(Date argDate, String argFormat) throws Exception {  
+        if (argDate == null) {  
+            throw new Exception("参数[日期]不能为空!");  
+        }  
+        if (StringUtils.isEmpty(argFormat)) {  
+            argFormat = Y_M_D;  
+        }  
+        SimpleDateFormat sdfFrom = new SimpleDateFormat(argFormat);  
+        return sdfFrom.format(argDate).toString();  
+    }  
+  
+    public static Date formatStringToDate(String argDateStr, String argFormat) throws Exception {  
+        if (argDateStr == null || argDateStr.trim().length() < 1) {  
+            throw new Exception("参数[日期]不能为空!");  
+        }  
+        String strFormat = argFormat;  
+        if (StringUtils.isEmpty(strFormat)) {  
+            strFormat = Y_M_D;  
+            if (argDateStr.length() > 16) {  
+                strFormat = Y_M_D_HMS;  
+            } else if (argDateStr.length() > 10) {  
+                strFormat = Y_M_D_HM;  
+            }  
+        }  
+        SimpleDateFormat sdfFormat = new SimpleDateFormat(strFormat);  
+        //严格模式  
+        sdfFormat.setLenient(false);  
+        try {  
+            return sdfFormat.parse(argDateStr);  
+        } catch (ParseException e) {  
+            throw new Exception(e);  
+        }  
+    } 
+}

src/main/java/com/dashitech/utils/MyX509TrustManager.java

@@ -0,0 +1,18 @@
+package com.dashitech.utils;
+
+import javax.net.ssl.X509TrustManager;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
+
+public class MyX509TrustManager implements X509TrustManager {
+	  
+    public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+    }  
+  
+    public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
+    }  
+  
+    public X509Certificate[] getAcceptedIssuers() {
+        return null;  
+    }  
+}  

src/main/java/com/dashitech/utils/OracleConn.java

@@ -0,0 +1,272 @@
+package com.dashitech.utils;
+
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by xuweihua on 2021/4/1.
+ */
+public class OracleConn {
+    private static String jdbc = PropertiesUtil.getProperty("oracle.conn.jdbc");
+    private static String user = PropertiesUtil.getProperty("oracle.user");
+    private static String pwd = PropertiesUtil.getProperty("oracle.password");
+
+    private static String user2 = PropertiesUtil.getProperty("oracle.user2");
+    private static String pwd2 = PropertiesUtil.getProperty("oracle.password2");
+
+    private static String jdbc2 = PropertiesUtil.getProperty("oracle.conn.jdbc2");
+    private static String jdbc3 = PropertiesUtil.getProperty("oracle.conn.jdbc3");
+
+    private static String user3 = PropertiesUtil.getProperty("oracle.user3");
+    private static String pwd3 = PropertiesUtil.getProperty("oracle.password3");
+
+    private static Connection  con = null;// 创建一个数据库连接
+    private static Connection  con2 = null;// 创建一个数据库连接
+    private static Connection  con3 = null;// 创建一个数据库连接
+    private static Connection  con4 = null;// 创建一个数据库连接
+
+
+    public List<Map<String, Object>> getOracleDataList(String sql) {
+        List<Map<String, Object>> list = new ArrayList<>();
+        PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
+        ResultSet result = null;// 创建一个结果集对象
+        try {
+            if(con == null) {
+                Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
+                //System.out.println("开始尝试连接数据库！");
+                con = DriverManager.getConnection(jdbc, user, pwd);// 获取连接
+                //System.out.println("连接成功！");
+            }
+            pre = con.prepareStatement(sql);
+            result = pre.executeQuery();
+            ResultSetMetaData md = result.getMetaData();// 获得结果集结构信息（元数据）
+            int columnCount = md.getColumnCount();// ResultSet列数
+            // ResultSet转List<Map>数据结构
+            // next用于移动到ResultSet的下一行，使下一行成为当前行
+            while (result.next()) {
+                Map<String, Object> map = new HashMap<>();
+                for (int i = 1; i <= columnCount; i++) {// 遍历获取对当前行的每一列的键值对，put到map中
+                    // rs.getObject(i) 获得当前行某一列字段的值
+                    map.put(md.getColumnName(i).toLowerCase(), result.getObject(i));
+                }
+                list.add(map);
+            }
+            return list;
+        }catch (Exception e) {
+            e.printStackTrace();
+            try {
+                if (con != null) { // 使用单例模式不关闭连接
+                    con.close();
+                    con = null;
+                    System.out.println("关闭数据库连接！");
+                }
+            }catch (Exception ex){
+                ex.printStackTrace();
+            }
+        } finally {
+            try {
+                // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
+                // 注意关闭的顺序，最后使用的最先关闭
+                if (result != null) {
+                    result.close();
+                }
+                if (pre != null) {
+                    pre.close();
+                }
+                if (con != null) { // 使用单例模式不关闭连接
+                    // con.close();
+                  //  System.out.println("关闭数据库连接！");
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 手术专用
+     * @param sql
+     * @return
+     */
+    public List<Map<String, Object>> getSurgeryOracleDataList(String sql) {
+        List<Map<String, Object>> list = new ArrayList<>();
+        PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
+        ResultSet result = null;// 创建一个结果集对象
+        try {
+            if(con2 == null) {
+                Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
+                //System.out.println("开始尝试连接数据库！");
+                con2 = DriverManager.getConnection(jdbc, user2, pwd2);// 获取连接
+                //System.out.println("连接成功！");
+            }
+            pre = con2.prepareStatement(sql);
+            result = pre.executeQuery();
+            ResultSetMetaData md = result.getMetaData();// 获得结果集结构信息（元数据）
+            int columnCount = md.getColumnCount();// ResultSet列数
+            // ResultSet转List<Map>数据结构
+            // next用于移动到ResultSet的下一行，使下一行成为当前行
+            while (result.next()) {
+                Map<String, Object> map = new HashMap<>();
+                for (int i = 1; i <= columnCount; i++) {// 遍历获取对当前行的每一列的键值对，put到map中
+                    // rs.getObject(i) 获得当前行某一列字段的值
+                    map.put(md.getColumnName(i).toLowerCase(), result.getObject(i));
+                }
+                list.add(map);
+            }
+            return list;
+        }catch (Exception e) {
+            e.printStackTrace();
+            try {
+                if (con2 != null) { // 使用单例模式不关闭连接
+                    con2.close();
+                    con2 = null;
+                    System.out.println("关闭数据库连接！");
+                }
+            }catch (Exception ex){
+                ex.printStackTrace();
+            }
+        } finally {
+            try {
+                // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
+                // 注意关闭的顺序，最后使用的最先关闭
+                if (result != null) {
+                    result.close();
+                }
+                if (pre != null) {
+                    pre.close();
+                }
+                if (con2 != null) { // 使用单例模式不关闭连接
+                    // con.close();
+                    //  System.out.println("关闭数据库连接！");
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 血制品
+     * @author song
+     * @date 2024/08/06
+     * @param sql
+     * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
+     */
+    public List<Map<String, Object>> getBloodOracleDataList(String sql) {
+        List<Map<String, Object>> list = new ArrayList<>();
+        PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
+        ResultSet result = null;// 创建一个结果集对象
+        try {
+            if(con3 == null) {
+                Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
+                con3 = DriverManager.getConnection(jdbc2, user3, pwd3);// 获取连接
+            }
+            pre = con3.prepareStatement(sql);
+            result = pre.executeQuery();
+            ResultSetMetaData md = result.getMetaData();// 获得结果集结构信息（元数据）
+            int columnCount = md.getColumnCount();// ResultSet列数
+            // ResultSet转List<Map>数据结构
+            // next用于移动到ResultSet的下一行，使下一行成为当前行
+            while (result.next()) {
+                Map<String, Object> map = new HashMap<>();
+                for (int i = 1; i <= columnCount; i++) {// 遍历获取对当前行的每一列的键值对，put到map中
+                    // rs.getObject(i) 获得当前行某一列字段的值
+                    map.put(md.getColumnName(i).toLowerCase(), result.getObject(i));
+                }
+                list.add(map);
+            }
+            return list;
+        }catch (Exception e) {
+            e.printStackTrace();
+            try {
+                if (con3 != null) { // 使用单例模式不关闭连接
+                    con3.close();
+                    con3 = null;
+                    System.out.println("关闭数据库连接！");
+                }
+            }catch (Exception ex){
+                ex.printStackTrace();
+            }
+        } finally {
+            try {
+                // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
+                // 注意关闭的顺序，最后使用的最先关闭
+                if (result != null) {
+                    result.close();
+                }
+                if (pre != null) {
+                    pre.close();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 标本
+     * @author song
+     * @date 2024/08/06
+     * @param sql
+     * @return java.util.List<java.util.Map<java.lang.String,java.lang.Object>>
+     */
+    public List<Map<String, Object>> getSpecimenOracleDataList(String sql) {
+        List<Map<String, Object>> list = new ArrayList<>();
+        PreparedStatement pre = null;// 创建预编译语句对象，一般都是用这个而不用Statement
+        ResultSet result = null;// 创建一个结果集对象
+        try {
+            if(con4 == null) {
+                Class.forName("oracle.jdbc.driver.OracleDriver");// 加载Oracle驱动程序
+                con4 = DriverManager.getConnection(jdbc3, user3, pwd3);// 获取连接
+            }
+            pre = con4.prepareStatement(sql);
+            result = pre.executeQuery();
+            ResultSetMetaData md = result.getMetaData();// 获得结果集结构信息（元数据）
+            int columnCount = md.getColumnCount();// ResultSet列数
+            // ResultSet转List<Map>数据结构
+            // next用于移动到ResultSet的下一行，使下一行成为当前行
+            while (result.next()) {
+                Map<String, Object> map = new HashMap<>();
+                for (int i = 1; i <= columnCount; i++) {// 遍历获取对当前行的每一列的键值对，put到map中
+                    // rs.getObject(i) 获得当前行某一列字段的值
+                    map.put(md.getColumnName(i).toLowerCase(), result.getObject(i));
+                }
+                list.add(map);
+            }
+            return list;
+        }catch (Exception e) {
+            e.printStackTrace();
+            try {
+                if (con4 != null) { // 使用单例模式不关闭连接
+                    con4.close();
+                    con4 = null;
+                    System.out.println("关闭数据库连接！");
+                }
+            }catch (Exception ex){
+                ex.printStackTrace();
+            }
+        } finally {
+            try {
+                // 逐一将上面的几个对象关闭，因为不关闭的话会影响性能、并且占用资源
+                // 注意关闭的顺序，最后使用的最先关闭
+                if (result != null) {
+                    result.close();
+                }
+                if (pre != null) {
+                    pre.close();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return list;
+    }
+
+
+}

src/main/java/com/dashitech/utils/Page.java

@@ -0,0 +1,49 @@
+package com.dashitech.utils;
+
+import java.io.Serializable;
+
+/**
+ * Created by xuweihua on 2021/4/2.
+ */
+public class Page implements Serializable {
+    private int pageNow = 1; // 当前页数
+    private int pageSize = 200; // 每页显示记录的条数（根据自身需求修改每页显示条数）
+    private int totalCount; // 总记录条数
+    private int totalPageCount; // 总页数
+    private int startPos; // 开始位置，从0开始
+    //构造函数,参数：总记录数和当前页
+    public Page(int totalCount, int pageNow) {
+        this.totalCount = totalCount;
+        this.pageNow = pageNow;
+    }
+    //计算总页数，总页数=总记录数/每页显示记录的条数
+    public int getTotalPageCount() {
+        totalPageCount = getTotalCount() / getPageSize();
+        return (totalCount % pageSize == 0) ? totalPageCount : totalPageCount + 1;
+    }
+    public void setTotalPageCount(int totalPageCount) {
+        this.totalPageCount = totalPageCount;
+    }
+    public int getPageNow() {
+        return pageNow;
+    }
+    public void setPageNow(int pageNow) {
+        this.pageNow = pageNow;
+    }
+    public int getPageSize() {
+        return pageSize;
+    }
+    public void setPageSize(int pageSize) {
+        this.pageSize = pageSize;
+    }
+    public int getTotalCount() {
+        return totalCount;
+    }
+    public void setTotalCount(int totalCount) {
+        this.totalCount = totalCount;
+    }
+    //取得选择记录的初始位置
+    public int getStartPos() {
+        return (pageNow - 1) * pageSize;
+    }
+}

src/main/java/com/dashitech/utils/PortalVerifystUtils.java

@@ -0,0 +1,61 @@
+package com.dashitech.utils;
+
+import com.alibaba.fastjson.JSONObject;
+
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.UUID;
+
+/**
+ * Created by xuweihua on 2021/3/5.
+ */
+public class PortalVerifystUtils {
+//    private static String SSO_VERIFYST = PropertiesUtil.getProperty("SSO_VERIFYST");
+//    private static SimpleDateFormat sdf2 = new SimpleDateFormat("yyyyMMddHHmmss");
+//    private static Client svclient;
+//    private static Client getClient(){
+//        if (svclient!=null){
+//            return svclient;
+//        }else{
+//            // 创建动态客户端
+//            JaxWsDynamicClientFactory dcf = JaxWsDynamicClientFactory.newInstance();
+//            svclient = dcf.createClient(SSO_VERIFYST);
+//            return svclient;
+//        }
+//    }
+//    public static String verifyst(String st,String Url){
+//        Client client = getClient();
+//        Object[] objects;
+//        try {
+//            String params = "<Request> \n" +
+//                    "<MessageHeader> \n" +
+//                    "<Sender>DSTECH</Sender> \n" +
+//                    "<Receiver>UUM</Receiver> \n" +
+//                    "<SendTime>"+sdf2.format(new Date())+"</SendTime> \n" +
+//                    "<EventType>SSO_VERIFYST</EventType> \n" +
+//                    "<MsgId>"+UUID.randomUUID()+"</MsgId> \n" +
+//                    "</MessageHeader> \n" +
+//                    "<MessageBody> \n" +
+//                    "<ST>"+st+"</ST> \n" +
+//                    "<Url>"+Url+"</Url> \n" +
+//                    "</MessageBody> \n" +
+//                    "</Request>";
+//            objects = client.invoke("initCasWebService", params);
+//            String redate = objects[0]+"";
+//            System.out.println("verifyst======================:" + redate);
+//            JSONObject jData= XmlToJson.xml2Json(redate);
+//            JSONObject result = jData.getJSONObject("MessageBody").getJSONObject("Result");
+//            if (result.getString("Code").equals("CA")){
+//                Object userId = jData.getJSONObject("MessageBody").get("UserId");
+//                if (userId!=null){
+//                    System.out.println("OK======================:" + userId);
+//                    return  userId+"";
+//                }
+//            }
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        }
+//        return null;
+//    }
+}

src/main/java/com/dashitech/utils/PropertiesHelper.java

@@ -0,0 +1,506 @@
+package com.dashitech.utils;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.InvalidPropertiesFormatException;
+import java.util.Map;
+import java.util.Properties;
+import java.util.Set;
+import java.util.Map.Entry;
+
+/**
+ * Properties的操作的工具类,为Properties提供一个代理增加相关工具方法如
+ * getRequiredString(),getInt(),getBoolean()等方法
+ * 并可以通过systemPropertiesMode属性指定是否搜索System.getProperty()及System.getenv()来查找值.
+ * 默认不搜索系统属性
+ * 
+ * <pre>
+ * 使用1:
+ * public class ConnectionUtils {
+ *     static Properties properties = new Properties(); 
+ *     // ... do load properties 
+ *     
+ *     // delegate to properties
+ * 	   static PropertiesHelper props = new PropertiesHelper(properties);
+ *     public static Connection getConnection() {
+ *     		// use getRequiredProperty() 
+ *     		DriverManager.getConnection(props.getRequiredString("jdbc.url"));
+ *     }
+ * }
+ * 指定是否搜索系统属性:
+ * new PropertiesHelper(properties,PropertiesHelper.SYSTEM_PROPERTIES_MODE_OVERRIDE)
+ * </pre>
+ * 
+ * @author badqiu
+ */
+public class PropertiesHelper {
+	/**
+	 * 不使用系统属性,这个是默认值
+	 **/
+	public static final int SYSTEM_PROPERTIES_MODE_NEVER = 0;
+
+	/**
+	 * 如果在properties中没有找到属性值,则查找系统属性
+	 */
+	public static final int SYSTEM_PROPERTIES_MODE_FALLBACK = 1;
+
+	/**
+	 * 首先查找系统属性,如果没有找到值,再查找properties,这可以用于系统属性覆盖properties中的值
+	 */
+	public static final int SYSTEM_PROPERTIES_MODE_OVERRIDE = 2;
+
+	private int systemPropertiesMode = SYSTEM_PROPERTIES_MODE_NEVER;
+
+	private Properties p;
+
+	public PropertiesHelper(Properties p) {
+		setProperties(p);
+	}
+
+	public PropertiesHelper(Properties p, int systemPropertiesMode) {
+		setProperties(p);
+		if (systemPropertiesMode != SYSTEM_PROPERTIES_MODE_NEVER && systemPropertiesMode != SYSTEM_PROPERTIES_MODE_FALLBACK
+				&& systemPropertiesMode != SYSTEM_PROPERTIES_MODE_OVERRIDE) {
+			throw new IllegalArgumentException("error systemPropertiesMode mode:" + systemPropertiesMode);
+		}
+		this.systemPropertiesMode = systemPropertiesMode;
+	}
+
+	public Properties getProperties() {
+		return p;
+	}
+
+	public void setProperties(Properties props) {
+		if (props == null)
+			throw new IllegalArgumentException("properties must be not null");
+		this.p = props;
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public String getRequiredProperty(String key) throws IllegalStateException {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			throw new IllegalStateException("required property is blank by key=" + key);
+		}
+		return value;
+	}
+
+	/**
+	 * 返回null,如果查值的属性值是blank
+	 * 
+	 * @param key
+	 * @return
+	 */
+	public String getNullIfBlank(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return value;
+	}
+
+	/**
+	 * 返回null,如果查值的属性值是empty
+	 * 
+	 * @param key
+	 * @return
+	 */
+	public String getNullIfEmpty(String key) {
+		String value = getProperty(key);
+		if (value == null || "".equals(value)) {
+			return null;
+		}
+		return value;
+	}
+
+	/**
+	 * 尝试从System.getProperty(key)及System.getenv(key)得到值
+	 * 
+	 * @return
+	 */
+	public String getAndTryFromSystem(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			value = getSystemProperty(key);
+		}
+		return value;
+	}
+
+	private String getSystemProperty(String key) {
+		String value;
+		value = System.getProperty(key);
+		if (isBlankString(value)) {
+			value = System.getenv(key);
+		}
+		return value;
+	}
+
+	public Integer getInteger(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return Integer.parseInt(value);
+	}
+
+	public int getInt(String key, int defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return Integer.parseInt(value);
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public int getRequiredInt(String key) throws IllegalStateException {
+		return Integer.parseInt(getRequiredProperty(key));
+	}
+
+	public Long getLong(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return Long.parseLong(value);
+	}
+
+	public long getLong(String key, long defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return Long.parseLong(value);
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public long getRequiredLong(String key) throws IllegalStateException {
+		return Long.parseLong(getRequiredProperty(key));
+	}
+
+	public Boolean getBoolean(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return Boolean.parseBoolean(value);
+	}
+
+	public boolean getBoolean(String key, boolean defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return Boolean.parseBoolean(value);
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public boolean getRequiredBoolean(String key) throws IllegalStateException {
+		return Boolean.parseBoolean(getRequiredProperty(key));
+	}
+
+	public Float getFloat(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return Float.parseFloat(value);
+	}
+
+	public float getFloat(String key, float defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return Float.parseFloat(value);
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public float getRequiredFloat(String key) throws IllegalStateException {
+		return Float.parseFloat(getRequiredProperty(key));
+	}
+
+	public Double getDouble(String key) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return null;
+		}
+		return Double.parseDouble(value);
+	}
+
+	public double getDouble(String key, double defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return Double.parseDouble(value);
+	}
+
+	/**
+	 * 必须存在这个key的值,不然抛 IllegalStateException异常
+	 **/
+	public double getRequiredDouble(String key) throws IllegalStateException {
+		return Double.parseDouble(getRequiredProperty(key));
+	}
+
+	public URL getURL(String key) throws IllegalArgumentException {
+		try {
+			return new URL(getProperty(key));
+		} catch (MalformedURLException e) {
+			throw new IllegalArgumentException("Property " + key + " must be a valid URL (" + getProperty(key) + ")");
+		}
+	}
+
+	public Object getClassInstance(String key) throws IllegalArgumentException {
+		String s = (String) getProperty(key);
+		if (s == null || "".equals(s.trim())) {
+			throw new IllegalArgumentException("Property " + key + " must be a valid classname  : " + key);
+		}
+		try {
+			return Class.forName(s).newInstance();
+		} catch (ClassNotFoundException nfe) {
+			throw new IllegalArgumentException(s + ": invalid class name for key " + key, nfe);
+		} catch (InstantiationException e) {
+			throw new IllegalArgumentException(s + ": class could not be reflected " + s, e);
+		} catch (IllegalAccessException e) {
+			throw new IllegalArgumentException(s + ": class could not be reflected " + s, e);
+		}
+	}
+
+	public Object getClassInstance(String key, Object defaultinstance) throws IllegalArgumentException {
+		return (containsKey(key) ? getClassInstance(key) : defaultinstance);
+	}
+
+	/**
+	 * 将一个property按"逗号,空格,换行符"分隔,并返回一个String[]数组
+	 **/
+	public String[] getStringArray(String key) {
+		String v = getProperty(key);
+		if (v == null) {
+			return new String[0];
+		} else {
+			return org.springframework.util.StringUtils.tokenizeToStringArray(v, ", \t\n\r\f");
+		}
+	}
+
+	/**
+	 * 将一个property按"逗号,空格,换行符"分隔,并返回一个int[]数组
+	 **/
+	public int[] getIntArray(String key) {
+		return toIntArray(getStringArray(key));
+	}
+
+	/**
+	 * 得到以某个前缀开始的所有属性,返回的属性值为移除前缀后的属性值.
+	 * 
+	 * @param prefix
+	 * @return
+	 */
+	public Properties getStartsWithProperties(String prefix) {
+		if (prefix == null)
+			throw new IllegalArgumentException("'prefix' must be not null");
+
+		Properties props = getProperties();
+
+		Properties result = new Properties();
+		for (Entry<Object, Object> entry : props.entrySet()) {
+			String key = (String) entry.getKey();
+			if (key != null && key.startsWith(prefix)) {
+				result.put(key.substring(prefix.length()), entry.getValue());
+			}
+		}
+		return result;
+	}
+
+	/** setProperty(String key,int value) ... start */
+
+	public Object setProperty(String key, int value) {
+		return setProperty(key, String.valueOf(value));
+	}
+
+	public Object setProperty(String key, long value) {
+		return setProperty(key, String.valueOf(value));
+	}
+
+	public Object setProperty(String key, float value) {
+		return setProperty(key, String.valueOf(value));
+	}
+
+	public Object setProperty(String key, double value) {
+		return setProperty(key, String.valueOf(value));
+	}
+
+	public Object setProperty(String key, boolean value) {
+		return setProperty(key, String.valueOf(value));
+	}
+
+	/** delegate method start */
+
+	public String getProperty(String key, String defaultValue) {
+		String value = getProperty(key);
+		if (isBlankString(value)) {
+			return defaultValue;
+		}
+		return value;
+	}
+
+	public String getProperty(String key) {
+		String propVal = null;
+		if (systemPropertiesMode == SYSTEM_PROPERTIES_MODE_OVERRIDE) {
+			propVal = getSystemProperty(key);
+		}
+		if (propVal == null) {
+			propVal = p.getProperty(key);
+		}
+		if (propVal == null && systemPropertiesMode == SYSTEM_PROPERTIES_MODE_FALLBACK) {
+			propVal = getSystemProperty(key);
+		}
+		return propVal == null ? null : propVal.trim();
+	}
+
+	public Object setProperty(String key, String value) {
+		return p.setProperty(key, value);
+	}
+
+	public void clear() {
+		p.clear();
+	}
+
+	public Set<Entry<Object, Object>> entrySet() {
+		return p.entrySet();
+	}
+
+	public Enumeration<?> propertyNames() {
+		return p.propertyNames();
+	}
+
+	public boolean contains(Object value) {
+		return p.contains(value);
+	}
+
+	public boolean containsKey(Object key) {
+		return p.containsKey(key);
+	}
+
+	public boolean containsValue(Object value) {
+		return p.containsValue(value);
+	}
+
+	public Enumeration<Object> elements() {
+		return p.elements();
+	}
+
+	public Object get(Object key) {
+		return p.get(key);
+	}
+
+	public boolean isEmpty() {
+		return p.isEmpty();
+	}
+
+	public Enumeration<Object> keys() {
+		return p.keys();
+	}
+
+	public Set<Object> keySet() {
+		return p.keySet();
+	}
+
+	public void list(PrintStream out) {
+		p.list(out);
+	}
+
+	public void list(PrintWriter out) {
+		p.list(out);
+	}
+
+	public void load(InputStream inStream) throws IOException {
+		p.load(inStream);
+	}
+
+	public void loadFromXML(InputStream in) throws IOException, InvalidPropertiesFormatException {
+		p.loadFromXML(in);
+	}
+
+	public Object put(Object key, Object value) {
+		return p.put(key, value);
+	}
+
+	public void putAll(Map<? extends Object, ? extends Object> t) {
+		p.putAll(t);
+	}
+
+	public Object remove(Object key) {
+		return p.remove(key);
+	}
+
+	/** @deprecated */
+	public void save(OutputStream out, String comments) {
+		p.save(out, comments);
+	}
+
+	public int size() {
+		return p.size();
+	}
+
+	public void store(OutputStream out, String comments) throws IOException {
+		p.store(out, comments);
+	}
+
+	public void storeToXML(OutputStream os, String comment, String encoding) throws IOException {
+		p.storeToXML(os, comment, encoding);
+	}
+
+	public void storeToXML(OutputStream os, String comment) throws IOException {
+		p.storeToXML(os, comment);
+	}
+
+	public Collection<Object> values() {
+		return p.values();
+	}
+
+	public String toString() {
+		return p.toString();
+	}
+
+	public static Properties restoreFromString(String str) {
+		if (str == null)
+			return new Properties();
+		Properties p = new Properties();
+		try {
+			p.load(new ByteArrayInputStream(str.getBytes()));
+		} catch (IOException e) {
+			throw new IllegalStateException("restore properties from String occer error. str:" + str, e);
+		}
+		return p;
+	}
+
+	private static boolean isBlankString(String value) {
+		return value == null || "".equals(value.trim());
+	}
+
+	private static int[] toIntArray(String[] array) {
+		int[] result = new int[array.length];
+		for (int i = 0; i < array.length; i++) {
+			result[i] = Integer.parseInt(array[i]);
+		}
+		return result;
+	}
+}

src/main/java/com/dashitech/utils/PropertiesUtil.java

@@ -0,0 +1,179 @@
+package com.dashitech.utils;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.util.Assert;
+
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Properties;
+
+/**
+ * 用于持有Properties,将Propereis变成静态方法使用.
+ */
+public class PropertiesUtil implements InitializingBean {
+	private static Log log = LogFactory.getLog(PropertiesUtil.class);
+
+	public static PropertiesHelper properies = null;
+
+	public void setProperties(Properties properies) {
+		Assert.isNull(PropertiesUtil.properies, "PropertiesUtil alreade hold properties");
+		PropertiesUtil.properies = new PropertiesHelper(properies);
+	}
+
+	// /**
+	// * 重新设置properties
+	// * @param properties
+	// */
+	// public void resetProperties(Properties properties) {
+	// clearHolder();
+	// new PropertiesUtil().setProperties(properties);
+	// }
+
+	/**
+	 * 清空 holder,只有清空Holder才可以重新设置 Properties
+	 */
+	public static void clearHolder() {
+		properies = null;
+	}
+
+	public static void setProperty(String key, String value) {
+		getRequiredHelper().setProperty(key, value);
+	}
+
+	/**
+	 * get readonly Properties
+	 **/
+	public static Properties getProperies() {
+		return (Properties) getRequiredHelper().getProperties().clone();
+	}
+
+	public static boolean getBoolean(String key, boolean defaultValue) {
+		return getRequiredHelper().getBoolean(key, defaultValue);
+	}
+
+	public static Boolean getBoolean(String key) {
+		return getRequiredHelper().getBoolean(key);
+	}
+
+	public static Object getClassInstance(String key, Object defaultinstance) throws IllegalArgumentException {
+		return getRequiredHelper().getClassInstance(key, defaultinstance);
+	}
+
+	public static Object getClassInstance(String key) throws IllegalArgumentException {
+		return getRequiredHelper().getClassInstance(key);
+	}
+
+	public static double getDouble(String key, double defaultValue) {
+		return getRequiredHelper().getDouble(key, defaultValue);
+	}
+
+	public static Double getDouble(String key) {
+		return getRequiredHelper().getDouble(key);
+	}
+
+	public static float getFloat(String key, float defaultValue) {
+		return getRequiredHelper().getFloat(key, defaultValue);
+	}
+
+	public static Float getFloat(String key) {
+		return getRequiredHelper().getFloat(key);
+	}
+
+	public static int getInt(String key, int defaultValue) {
+		return getRequiredHelper().getInt(key, defaultValue);
+	}
+
+	public static int[] getIntArray(String key) {
+		return getRequiredHelper().getIntArray(key);
+	}
+
+	public static Integer getInteger(String key) {
+		return getRequiredHelper().getInteger(key);
+	}
+
+	public static long getLong(String key, long defaultValue) {
+		return getRequiredHelper().getLong(key, defaultValue);
+	}
+
+	public static Long getLong(String key) {
+		return getRequiredHelper().getLong(key);
+	}
+
+	public static String getNullIfBlank(String key) {
+		return getRequiredHelper().getNullIfBlank(key);
+	}
+
+	public static String getNullIfEmpty(String key) {
+		return getRequiredHelper().getNullIfEmpty(key);
+	}
+
+	public static String getProperty(String key, String defaultValue) {
+		return getRequiredHelper().getProperty(key, defaultValue);
+	}
+
+	public static String getProperty(String key) {
+		return getRequiredHelper().getProperty(key);
+	}
+
+	public static boolean getRequiredBoolean(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredBoolean(key);
+	}
+
+	public static double getRequiredDouble(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredDouble(key);
+	}
+
+	public static float getRequiredFloat(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredFloat(key);
+	}
+
+	public static int getRequiredInt(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredInt(key);
+	}
+
+	public static long getRequiredLong(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredLong(key);
+	}
+
+	public static String getRequiredProperty(String key) throws IllegalStateException {
+		return getRequiredHelper().getRequiredProperty(key);
+	}
+
+	public static Properties getStartsWithProperties(String prefix) {
+		return getRequiredHelper().getStartsWithProperties(prefix);
+	}
+
+	public static String[] getStringArray(String key) {
+		return getRequiredHelper().getStringArray(key);
+	}
+
+	public static URL getURL(String key) throws IllegalArgumentException {
+		return getRequiredHelper().getURL(key);
+	}
+
+	private static PropertiesHelper getRequiredHelper() {
+		assertHolderInited();
+		return properies;
+	}
+
+	private static void assertHolderInited() {
+		if (properies == null)
+			throw new IllegalStateException("PropertiesUtil.properties must be not null, PropertiesUtil not yet init.");
+	}
+
+	public void afterPropertiesSet() throws Exception {
+		assertHolderInited();
+		log.info("PropertiesUtil holded properties:" + getProperies());
+	}
+	
+	public static Map<String,String> getAsMap() {
+		Map<String,String> configs = new HashMap<String, String>();
+		for( Map.Entry<Object,Object> entry : properies.entrySet()) {
+			configs.put(entry.getKey().toString(), entry.getValue().toString());
+		}
+		return configs;
+	}
+}

src/main/java/com/dashitech/utils/Sha1Util.java

@@ -0,0 +1,69 @@
+package com.dashitech.utils;
+
+
+import java.security.MessageDigest;
+import java.util.Formatter;
+import java.util.UUID;
+
+public class Sha1Util {
+
+    public static String getNonce() {
+        String uuid = UUID.randomUUID().toString();
+        return uuid;
+    }
+
+    public static String getTimestamp() {
+        return String.valueOf(System.currentTimeMillis() / 1000);
+    }
+
+
+    private static String byteToHex(final byte[] hash) {
+        Formatter formatter = new Formatter();
+        for (byte b : hash) {
+            formatter.format("%02x", b);
+        }
+        String result = formatter.toString();
+        formatter.close();
+        return result;
+    }
+
+    //SHA1
+    public static String sha1(String str) {
+        if (str == null || str.length() == 0) {
+            return null;
+        }
+        char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+
+        try {
+            MessageDigest mdTemp = MessageDigest.getInstance("SHA1");
+            mdTemp.update(str.getBytes("UTF-8"));
+
+            byte[] md = mdTemp.digest();
+            int j = md.length;
+            char buf[] = new char[j * 2];
+            int k = 0;
+            for (int i = 0; i < j; i++) {
+                byte byte0 = md[i];
+                buf[k++] = hexDigits[byte0 >>> 4 & 0xf];
+                buf[k++] = hexDigits[byte0 & 0xf];
+            }
+            return new String(buf);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    //SHA-1
+    public static String sha_1(String str) {
+        try {
+            MessageDigest crypt = MessageDigest.getInstance("SHA-1");
+            crypt.reset();
+            crypt.update(str.getBytes("UTF-8"));
+            String signature = byteToHex(crypt.digest());
+            return signature;
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+        return null;
+    }
+}

src/main/java/com/dashitech/utils/SpringContextHolder.java

@@ -0,0 +1,68 @@
+package com.dashitech.utils;
+
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+
+import java.lang.annotation.Annotation;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 以静态变量保存Spring ApplicationContext, 可在任何地方getBean
+ */
+public class SpringContextHolder implements ApplicationContextAware {
+    private static ApplicationContext applicationContext;
+
+    /**
+     * 实现ApplicationContextAware接口的context注入函数, 将其存入静态变量.
+     */
+    @Override
+    public void setApplicationContext(ApplicationContext applicationContext) {
+        SpringContextHolder.applicationContext = applicationContext; // NOSONAR
+    }
+
+    /**
+     * 取得存储在静态变量中的ApplicationContext.
+     */
+    public static ApplicationContext getApplicationContext() {
+        checkApplicationContext();
+        return applicationContext;
+    }
+
+    public static <T> T getBean(String name) {
+        return (T) getApplicationContext().getBean(name);
+    }
+
+    public static <T> T getBean(Class<T> clazz) {
+        return (T) getApplicationContext().getBeansOfType(clazz);
+    }
+
+    public static <T> T getBean(Class<T> beanType, Class<? extends Annotation> annotationType) {
+        if (annotationType == null) {
+            return getBean(beanType);
+        }
+        Map<String, T> results = getApplicationContext().getBeansOfType(beanType);
+        List<T> resultsWithAnnotation = new ArrayList<T>();
+        for (Map.Entry<String, T> entry : results.entrySet()) {
+            if (getApplicationContext().findAnnotationOnBean(entry.getKey(), annotationType) != null) {
+                resultsWithAnnotation.add(entry.getValue());
+            }
+        }
+        if (resultsWithAnnotation.isEmpty()) {
+            return null;
+        }
+        if (resultsWithAnnotation.size() == 1) {
+            return resultsWithAnnotation.get(0);
+        }
+        throw new IllegalStateException("参数错误！未获取到对应Bean");
+    }
+
+
+    private static void checkApplicationContext() {
+        if (applicationContext == null) {
+            throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextHolder");
+        }
+    }
+
+}

src/main/java/com/dashitech/utils/ThreadPoolFactory.java

@@ -0,0 +1,31 @@
+package com.dashitech.utils;
+
+import java.util.concurrent.*;
+
+/**
+ * Created by chi on 2020/8/25.
+ */
+
+public abstract class ThreadPoolFactory {
+   // private static final Logger LOG = LoggerFactory.getLogger(ThreadPoolFactory.class);
+    private static ThreadPoolExecutor pool;
+    private static ScheduledThreadPoolExecutor scheduler;
+
+    public synchronized static ExecutorService getCachedPool() {
+        if (pool == null) {
+            pool = (ThreadPoolExecutor) Executors.newCachedThreadPool();
+         //   LOG.info("缓存线程池启动完成！初始化线程池大小：" + pool.getPoolSize());
+        }
+        return pool;
+    }
+
+    public synchronized static ScheduledExecutorService getScheduledPool() {
+        if (scheduler == null) {
+            scheduler = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(35);
+           // LOG.info("定时线程池启动完成！初始化线程池大小：" + scheduler.getPoolSize());
+        }
+        return scheduler;
+    }
+
+}
+

src/main/java/com/dashitech/utils/XmlToMap.java

@@ -0,0 +1,83 @@
+package com.dashitech.utils;
+
+import org.dom4j.Document;
+import org.dom4j.DocumentHelper;
+import org.dom4j.Element;
+
+import java.util.*;
+
+/**
+ * Created by xuweihua on 2021/3/29.
+ */
+public class XmlToMap {
+    public static Map<String, Object> Dom2Map(String xmlStr){
+        Map<String, Object> map = new HashMap<String, Object>();
+        try{
+            Document doc= DocumentHelper.parseText(xmlStr);
+            if(doc == null)
+                return null;
+            Element root = doc.getRootElement();
+            for (Iterator iterator = root.elementIterator(); iterator.hasNext();) {
+                Element e = (Element) iterator.next();
+                //System.out.println(e.getName());
+                List list = e.elements();
+                if(list.size() > 0){
+                    map.put(e.getName(), Dom2Map(e));
+                }else
+                    map.put(e.getName(), e.getText());
+            }
+            return map;
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+
+    public static Map Dom2Map(Element e){
+        Map map = new HashMap();
+        List list = e.elements();
+        if(list.size() > 0){
+            for (int i = 0;i < list.size(); i++) {
+                Element iter = (Element) list.get(i);
+                List mapList = new ArrayList();
+
+                if(iter.elements().size() > 0){
+                    Map m = Dom2Map(iter);
+                    if(map.get(iter.getName()) != null){
+                        Object obj = map.get(iter.getName());
+                        if(!obj.getClass().getName().equals("java.util.ArrayList")){
+                            mapList = new ArrayList();
+                            mapList.add(obj);
+                            mapList.add(m);
+                        }
+                        if(obj.getClass().getName().equals("java.util.ArrayList")){
+                            mapList = (List) obj;
+                            mapList.add(m);
+                        }
+                        map.put(iter.getName(), mapList);
+                    }else
+                        map.put(iter.getName(), m);
+                }
+                else{
+                    if(map.get(iter.getName()) != null){
+                        Object obj = map.get(iter.getName());
+                        if(!obj.getClass().getName().equals("java.util.ArrayList")){
+                            mapList = new ArrayList();
+                            mapList.add(obj);
+                            mapList.add(iter.getText());
+                        }
+                        if(obj.getClass().getName().equals("java.util.ArrayList")){
+                            mapList = (List) obj;
+                            mapList.add(iter.getText());
+                        }
+                        map.put(iter.getName(), mapList);
+                    }else
+                        map.put(iter.getName(), iter.getText());
+                }
+            }
+        }else
+            map.put(e.getName(), e.getText());
+        return map;
+    }
+}

src/main/resources/application-context.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+	xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:aop="http://www.springframework.org/schema/aop"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
+	xsi:schemaLocation="http://www.springframework.org/schema/beans
+						http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+						http://www.springframework.org/schema/mvc
+						http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
+						http://www.springframework.org/schema/aop 
+						http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
+						http://www.springframework.org/schema/context
+						http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+
+
+	<!-- 初始化静态资源类 -->
+	<bean id="applicationProperties"
+		class="org.springframework.beans.factory.config.PropertiesFactoryBean">
+		<property name="ignoreResourceNotFound" value="true" />
+		<property name="locations">
+			<list>
+				<value>classpath:application.properties</value>
+				<value>classpath:application-custom.properties</value>
+			</list>
+		</property>
+	</bean>
+
+	<bean class="com.dashitech.utils.PropertiesUtil" lazy-init="false">
+		<property name="properties" ref="applicationProperties" />
+	</bean>
+
+	<bean class="com.dashitech.utils.SpringContextHolder" lazy-init="false" />
+</beans>

src/main/resources/application-custom.properties

@@ -0,0 +1 @@
+custom.redis.expire=60

src/main/resources/application.properties

@@ -0,0 +1,55 @@
+
+mysql2.spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
+mysql2.spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+#mysql2.spring.datasource.url=jdbc:mysql://172.16.100.186:3306/hsms2?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+#mysql2.spring.datasource.url=jdbc:mysql://192.168.3.108:3306/hsms2_0622?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+mysql2.spring.datasource.url=jdbc:mysql://192.168.3.108:3306/hsms_nanjing?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+mysql2.spring.datasource.username=root
+mysql2.spring.datasource.password=100100
+mysql2.spring.datasource.initialSize=5
+mysql2.spring.datasource.minIdle=1
+mysql2.spring.datasource.maxActive=150
+mysql2.spring.datasource.maxWait=60000
+mysql2.spring.datasource.timeBetweenEvictionRunsMillis=60000
+mysql2.spring.datasource.minEvictableIdleTimeMillis=300000
+mysql2.spring.datasource.validationQuery=SELECT 'x'
+mysql2.spring.datasource.testWhileIdle=true
+mysql2.spring.datasource.testOnBorrow=true
+mysql2.spring.datasource.testOnReturn=true
+
+mysql3.spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
+mysql3.spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+#mysql3.spring.datasource.url=jdbc:mysql://172.16.100.186:3306/hsms2?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+#mysql3.spring.datasource.url=jdbc:mysql://192.168.3.108:3306/hsms2_0622?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+mysql3.spring.datasource.url=jdbc:mysql://192.168.3.108:3306/md2_nanjing?autoReconnect=true&useUnicode=true&characterEncoding=utf8
+mysql3.spring.datasource.username=root
+mysql3.spring.datasource.password=100100
+mysql3.spring.datasource.initialSize=5
+mysql3.spring.datasource.minIdle=1
+mysql3.spring.datasource.maxActive=150
+mysql3.spring.datasource.maxWait=60000
+mysql3.spring.datasource.timeBetweenEvictionRunsMillis=60000
+mysql3.spring.datasource.minEvictableIdleTimeMillis=300000
+mysql3.spring.datasource.validationQuery=SELECT 'x'
+mysql3.spring.datasource.testWhileIdle=true
+mysql3.spring.datasource.testOnBorrow=true
+mysql3.spring.datasource.testOnReturn=true
+
+
+
+spring.redis.host=localhost
+#spring.redis.host=172.16.100.176
+spring.redis.port=6379
+spring.redis.password=Redis@#6379pwD
+spring.redis.pool.max-total=100
+spring.redis.pool.max-idle=20
+spring.redis.pool.max-wait-millis=10000
+spring.profiles.active=custom
+spring.redis.topic=hsms-data-service
+
+server.port=29999
+spring.jps.showsql=true
+server.tomcat.compression=on
+
+spring.jackson.parser.allow-numeric-leading-zeros=true
+

src/main/resources/banner.txt

@@ -0,0 +1,22 @@
+////////////////////////////////////////////////////////////////////
+//                          _ooOoo_                               //
+//                         o8888888o                              //
+//                         88" . "88                              //
+//                         (| ^_^ |)                              //
+//                         O\  =  /O                              //
+//                      ____/`---'\____                           //
+//                    .'  \\|     |//  `.                         //
+//                   /  \\|||  :  |||//  \                        //
+//                  /  _||||| -卍-|||||-  \                       //
+//                  |   | \\\  -  /// |   |                       //
+//                  | \_|  ''\---/''  |   |                       //
+//                  \  .-\__  `-`  ___/-. /                       //
+//                ___`. .'  /--.--\  `. . ___                     //
+//              ."" '<  `.___\_<|>_/___.'  >'"".                  //
+//            | | :  `- \`.;`\ _ /`;.`/ - ` : | |                 //
+//            \  \ `-.   \_ __\ /__ _/   .-` /  /                 //
+//      ========`-.____`-.___\_____/___.-`____.-'========         //
+//                           `=---='                              //
+//      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        //
+//          佛祖保佑   永不宕机   永无BUG  大势雄起               //
+////////////////////////////////////////////////////////////////////

src/main/resources/log4j.properties

@@ -0,0 +1,5 @@
+log4j.rootLogger=WARN,ERROR
+
+log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender
+log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout
+log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %-5p %c - %m%n

src/main/resources/start.bat

@@ -0,0 +1,5 @@
+echo "start ing"
+
+java -Xmx512m -XX:MaxPermSize=256m -jar C:/Users/Administrator/Desktop/hsmsV1-DataService-1.0.0.jar --server.port=29999 &
+
+echo "start end"

src/main/resources/start.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+HOME=`pwd`
+NAME=hsmsV1-DataService
+LOG=$HOME/logs/itsm.log
+
+echo "service $NAME start"
+echo ""
+
+
+
+nohup java -server -Xms256m -Djava.security.egd=file:/dev/./urandom -jar /home/itsm/itsm_v2/hsmsV1-DataService/HSMSV1-DataService-1.0.0.jar --server.port=9999 > $LOG 2>&1 &
+
+echo ""
+echo "service $NAME completed"

src/main/resources/startCollect.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+NAME=hsmsV1-DataService
+
+echo "service $NAME start"
+echo ""
+
+HOME=`pwd`
+LOG=$HOME/logs/itsm.log
+CONFS=$HOME/conf
+CLASSES=$HOME/classes
+LIBS=$HOME/lib
+JARS=`ls $LIBS|grep .jar|awk '{print "'$LIBS'/"$0}'|tr "\n" ":"`
+JAVA_OPTS=" -server -Xms10g -Xmx20g -XX:PermSize=2g -XX:SurvivorRatio=2 -XX:+UseParallelGC "
+CLASS_PATH=$CONFS:$CLASSES:$JARS:$NAME
+
+nohup java $JAVA_OPTS -classpath $CLASS_PATH com.dashitech.Application > $LOG 2>&1 &
+
+echo ""
+echo "service $NAME completed"

src/main/webapp/WEB-INF/web.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
+        "http://java.sun.com/dtd/web-app_2_3.dtd">
+<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
+  <display-name></display-name>
+
+    <servlet>
+        <servlet-name>AtmosphereServlet</servlet-name>
+        <servlet-class>org.atmosphere.cpr.AtmosphereServlet</servlet-class>
+        <init-param>
+            <param-name>org.atmosphere.cpr.packages</param-name>
+            <param-value>com.dashitech.callcenter.webSocket.service</param-value>
+        </init-param>
+        <load-on-startup>0</load-on-startup>
+    </servlet>
+
+
+    <servlet-mapping>
+        <servlet-name>AtmosphereServlet</servlet-name>
+        <url-pattern>/webSocket/*</url-pattern>
+    </servlet-mapping>
+
+
+</web-app>

src/test/java/com/dashitech/mc/AppTest.java

@@ -0,0 +1,38 @@
+package com.dashitech.mc;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+/**
+ * Unit test for simple App.
+ */
+public class AppTest 
+    extends TestCase
+{
+    /**
+     * Create the test case
+     *
+     * @param testName name of the test case
+     */
+    public AppTest( String testName )
+    {
+        super( testName );
+    }
+
+    /**
+     * @return the suite of tests being tested
+     */
+    public static Test suite()
+    {
+        return new TestSuite( AppTest.class );
+    }
+
+    /**
+     * Rigourous Test :-)
+     */
+    public void testApp()
+    {
+        assertTrue( true );
+    }
+}