本文主要介绍 SpringCould 组件   Ribbon , Eureka 实现负载均衡 
其实实现负载均衡方式有很多
比如，Nginx LVS ....等

概述：
服务消费端 80（端口）
服务提供者 8001，8002 ，8003  （端口）
服务注册中心 7001，7003，7003  （端口）

package com.jorden.server.eureka;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
/**
 * 
* @ClassName: EurekaApplicationStart
* @Description: eureka服务注册
* @author liwenqiang	
* @date 2017年12月5日 下午1:02:32
*
 */
@SpringBootApplication
@EnableEurekaServer	
public class EurekaApplicationStart {
	public static void main(String[] args) throws Exception {
		SpringApplication.run(EurekaApplicationStart.class, args);
	}
}

server:
  port: 7004
  
spring:
  application:
    name: eureka-7004.com
  
##  eureak实例定义 
eureka:
  instance:
  ## 定义 Eureka 实例所在的主机名称 
    hostname: eureka-7004.com
    
  client:
      service-url: 
       defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7003.com:7003/eureka
      register-with-eureka: false  # 当前的微服务不注册到eureka之中 
      fetch-registry: false  # 不通过eureka获取注册信息

server:
  port: 8001
mybatis:
  config-location: classpath:mybatis/mybatis.cfg.xml    # mybatis配置文件所在路径
  type-aliases-package: com.jorden.li.domain            # 定义所有操作类的别名所在包
  mapper-locations:                                     # 所有的mapper映射文件
  - classpath:mybatis/mapper/*.xml
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource    # 配置当前要使用的数据源的操作类型
    driver-class-name: org.gjt.mm.mysql.Driver      # 配置MySQL的驱动程序类
    url: jdbc:mysql://localhost:3306/mldn8001           # 数据库连接地址
    username: root                                  # 数据库用户名
    password: 123456                            # 数据库连接密码
    dbcp2:                                          # 进行数据库连接池的配置
      min-idle: 5                                   # 数据库连接池的最小维持连接数    
      initial-size: 5                               # 初始化提供的连接数
      max-total: 5                                  # 最大的连接数
      max-wait-millis: 200                          # 等待连接获取的最大超时时间
  application:
    name: microcloud-provider-dept  
## # 客户端进行Eureka注册的配置 
eureka:
  client:
     service-url: 
       defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7003.com:7003/eureka ,http://eureka-7004.com:7004/eureka 
  instance:
    instance-id: dept-8001.com 
    prefer-ip-address: true
    lease-renewal-interval-in-seconds: 2 # 设置心跳的时间间隔（默认是30秒）   
    lease-expiration-duration-in-seconds: 5 # 如果现在超过了5秒的间隔（默认是90秒）

package com.jorden.li.web;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.jorden.li.dao.service.IDeptService;
import com.jorden.li.domain.Dept;
/**
 * 
* @ClassName: DeptRest
* @Description: TODO(这里用一句话描述这个类的作用)
* @author liwenqiang	
* @date 2017年12月5日 上午11:20:10
*
 */
@RestController
public class DeptRest {
	@Resource
	private IDeptService deptService;
	@RequestMapping(value = "/dept/get/{id}", method = RequestMethod.GET)
	public Object get(@PathVariable("id") long id) {
		return this.deptService.get(id);
	}
	@RequestMapping(value = "/dept/add", method = RequestMethod.GET)
	public Object add(@RequestBody Dept dept) {
		return this.deptService.add(dept);
	}
	@RequestMapping(value = "/dept/list", method = RequestMethod.GET)
	public Object list() {
		return this.deptService.list();
	}
}

package com.jorden.li;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
/**
 * microcloud-provider-dept-8001
 * 
 * 启动配置类
 * @author  wqli
 *
 */
@SpringBootApplication
@EnableEurekaClient
public class ApplicationStart {
	public static void main(String[] args) throws Exception {
		SpringApplication.run(ApplicationStart.class, args);
	}
	
	
	
}

server:
  port: 80
## 服务注册
eureka: 
  client: 
    register-with-eureka: false 
    service-url: 
      defaultZone: http://eureka-7001.com:7001/eureka,
      http://eureka-7003.com:7003/eureka, 
      http://eureka-7004.com:7004/eureka

package com.jorden.config;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
/**
 * 
* @ClassName: RestConfig
* @Description: TODO(这里用一句话描述这个类的作用)
* @author liwenqiang	
* @date 2017年12月5日 上午11:13:50
*
 */
@Configuration
public class RestConfig {
	
	/**
	 * 
	* @Title: getRestTemplate
	* @Description: TODO(负载均衡配置) @LoadBalanced
	* @param @return    设定文件
	* @return RestTemplate    返回类型
	* @throws
	* 
	 */
	@Bean
	@LoadBalanced
	public RestTemplate getRestTemplate() {
		return new RestTemplate();
	}
}

package com.jorden.web;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import com.jorden.li.domain.Dept;
/**
 * 
 * @ClassName: ConsumerDeptController
 * @Description: TODO(这里用一句话描述这个类的作用)
 * @author liwenqiang
 * @date 2017年12月5日 上午11:21:23
 *
 */
@RestController
public class ConsumerDeptController {
	private static String url = "MICROCLOUD-PROVIDER-DEPT";
	@Autowired
	private RestTemplate restTemplate;
	public static final String DEPT_GET_URL = "http://" + url + "/dept/get/";
	public static final String DEPT_GETLISGT_URL = "http://" + url + "/dept/list";
	@RequestMapping(value = "/consumer/dept/{id}")
	public Object getDept(@PathVariable("id") Long id) {
		Dept dept = this.restTemplate.getForObject(DEPT_GET_URL + id, Dept.class);
		return dept;
	}
	
}

@SpringBootApplication
@EnableEurekaClient
public class ApplicationStart {
	public static void main(String[] args) throws Exception {
		SpringApplication.run(ApplicationStart.class, args);
	}
}

* 存储过程是一个预编译的代码块，执行效率比较高
* 一个存储过程替代大量T_SQL语句 ，可以降低网络通信量，提高通信速率
* 可以一定程度上确保数据安全

* 索引加快数据库的检索速度
* 索引降低了插入、删除、修改等维护任务的速度
* 唯一索引可以确保每一行数据的唯一性 比如说:主键索引

一：硬件优化，提高机器性能，增加硬件等; 
二：优化查询语句，将限定性强的where条件放前
三：优化索引，建立有效的索引
如何继续问这个优化问题，你就说不怎么了解，你知道一个大数据下
数据库分库分表的问题
可以举一个最简单的问题：
上海的公交卡的信息记录
上海假设就 两千万的人做公交，每天上下班也算上
那么日积月累一个月就是30*两千万。一个数据库根本就不可能
，你就可以这么说。按照每天分表。
昨天是20170921一个数据库
今天是20170921一个数据库
每天是20170922一个数据库
这个就是分库。
  
分表也是同样的道理
分表就是表拆开：
 经常用的字段一个表 不经常用的放另外一个表。用id关联

import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
@ConditionalOnProperty(prefix = "common",name="enable", matchIfMissing=true)
public class SwaggerConfiguration {
    ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("项目API")
                .description("提供服务端restful在线接口文档，若需求变更,请刷新页面重新获取信息。")
                .termsOfServiceUrl("")
                .version("1.0.0")
                .contact(new Contact("lwq","","wqli@ewininfo.com"))
                .termsOfServiceUrl("http://localhost:8089/")
                .build();
        
    }
    @Bean
    @ConditionalOnMissingBean()//容器中如果没有Docket这个类,那么自动配置这个Docket
    public Docket createRestApi() {
    	return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()// 选择那些路径和api会生成document
                .apis(RequestHandlerSelectors.basePackage("com.company.project.web"))// 对所有包进行监控
                .paths(PathSelectors.any())// 对所有路径进行监控
                .build();
    }
}

package template.mybatis.springboot.authorization.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 在Controller的方法上使用此注解，该方法在映射时会检查用户是否登录，未登录返回401错误
 * @author lwq
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Authorization {
}

package template.mybatis.springboot.authorization.manager.impl;
import template.mybatis.springboot.authorization.model.TokenModel;
/**
 * 对Token进行操作的接口
 * @author lwq
 */
public interface TokenManager {
    /**
     * 创建一个token关联上指定用户
     * @param userId 指定用户的id
     * @return 生成的token
     */
    public TokenModel createToken(String userId);
    /**
     * 检查token是否有效
     * @param model token
     * @return 是否有效
     */
    public boolean checkToken(String authorization);
    /**
     * 从字符串中解析token
     * @param authentication 加密后的字符串
     * @return
     */
    public TokenModel getToken(String authentication);
    /**
     * 清除token
     * @param userId 登录用户的id
     */
    public void deleteToken(String authentication);
}

package template.mybatis.springboot.authorization.manager.impl;
import java.util.concurrent.TimeUnit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import com.xiaoleilu.hutool.crypto.SecureUtil;
import com.xiaoleilu.hutool.json.JSONUtil;
import lombok.Data;
import template.mybatis.springboot.authorization.model.TokenModel;
/**
 *  
 *  token redis Manager
 *
 */
@Component
@Data
public class RedisTokenManager implements TokenManager{
	
	@Autowired
	private RedisTemplate<String, String> redisTemplate;
	
	
	
	@Override
	public TokenModel createToken(String userId) {
		String token = SecureUtil.simpleUUID();
		TokenModel TokenModel=new TokenModel(userId, token);
		String value = JSONUtil.toJsonStr(TokenModel);
		redisTemplate.boundValueOps(token)
		.set(value, template.mybatis.springboot.model.Constants.TOKEN_EXPIRES_HOUR, TimeUnit.HOURS); //一天过期时间
		return TokenModel;
	}
	@Override
	public boolean checkToken(String token) {
		//
		if(!(StringUtils.isEmpty(token))){
			String json = redisTemplate.boundValueOps(token).get();
			com.xiaoleilu.hutool.json.JSONObject parseObj = JSONUtil.parseObj(json);
			TokenModel bean = parseObj.toBean(TokenModel.class);
			if(token.equals(bean.getToken())){
				//程序授权过期时间
				return	 redisTemplate.boundValueOps(token)	.expire(template.mybatis.springboot.model.Constants.TOKEN_EXPIRES_HOUR, TimeUnit.HOURS);
			}
		}
		
		return false;
	}
	@Override
	public TokenModel getToken(String authentication) {
		//获取
				String json = redisTemplate.boundValueOps(authentication).get();
//				JSONUtil.
				com.xiaoleilu.hutool.json.JSONObject parseObj = JSONUtil.parseObj(json);
				TokenModel bean = parseObj.toBean(TokenModel.class);
				return bean;
	}
	@Override
	public void deleteToken(String authentication) {
		redisTemplate.delete(authentication);
	}
}
}
注释：@Data 采用了lombok  有兴趣的同学可以学习一下，本人觉得非常好呀。

package template.mybatis.springboot.authorization.interceptor;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import com.alibaba.druid.util.StringUtils;
import template.mybatis.springboot.authorization.annotation.Authorization;
import template.mybatis.springboot.authorization.manager.impl.TokenManager;
/**
 *   
 *   1，判断请求是否要权限认证 
 *   2.进行redis权限认证
 *   
 */
@Component
public class AuthorizationIntercetor extends HandlerInterceptorAdapter {
	
	@Autowired
	TokenManager redisTokenManager;
	
	/**
	 * This implementation always returns {@code true}.
	 */
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		//映射的不是方法
		if(!(handler instanceof HandlerMethod)){
			
			return true;
		}
		HandlerMethod handlerMethod =(HandlerMethod) handler;
		Method method = handlerMethod.getMethod();
		//得到该处理器是否需要认证
		Authorization annotation = method.getAnnotation(Authorization.class);
		if(annotation==null){
			return true;
		}else{
			   String authorization = request.getHeader(template.mybatis.springboot.model.Constants.AUTHORIZATION);
			   if(!StringUtils.isEmpty(authorization)){
				   
				   boolean checkToken = redisTokenManager.checkToken(authorization);
				   if(checkToken){
					   return true;
				   }else{
					   returnJson(response, "授权失败");
				   }
				   
			   }else{
				   returnJson(response, "该接口未认证或者未签名或者不存在此资源");
			   }
			   
		}
		
		
		
		
		
		return true;
	}
	/**
	 * This implementation is empty.
	 */
	@Override
	public void postHandle(
			HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
			throws Exception {
	}
	/**
	 * This implementation is empty.
	 */
	@Override
	public void afterCompletion(
			HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
	}
	/**
	 * This implementation is empty.
	 */
	@Override
	public void afterConcurrentHandlingStarted(
			HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
	}
	
	
	/**
     * 异常返回
     * @param response
     * @param json
     * @throws Exception
     */
    private void returnJson(HttpServletResponse response, String json) throws Exception{
        PrintWriter writer = null;
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json;charset=utf-8");
        try {
            writer = response.getWriter();
            writer.print(json);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (writer != null)
                writer.close();
        }
    }
}

import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import template.mybatis.springboot.authorization.manager.impl.TokenManager;
import template.mybatis.springboot.authorization.model.TokenModel;
import template.mybatis.springboot.model.ResultModel;
import template.mybatis.springboot.model.UserInfo;
import template.mybatis.springboot.service.UserInfoService;
/**
 * @author lwq
 */
@RestController
@RequestMapping("/users")
public class UserInfoController {
    @Autowired
    private UserInfoService userInfoService;
    @Autowired
	private TokenManager tokenManager;
    
    /**
     * 登录以及授权
     */
    @ResponseBody
    @RequestMapping("/login")
    public ResponseEntity<ResultModel> login(@RequestBody Map<String, String> request ) {
    	UserInfo login = userInfoService.login(request.get("username"), request.get("password"));
    	if(login!=null){
    		TokenModel createToken = tokenManager.createToken(request.get("username"));
    		return ResultModel.success(createToken);
    	}else{
    		return ResultModel.fail(403, "用户名或密码错误");
    		
    	}
    }
}

{
  "code": 100,
  "message": "成功",
  "data": {
    "userId": "admin",
    "token": "d99fd350c5d94231b017b6a9b1d4f089"
  },
  "total": 0
}

 			
 			
 			import javax.servlet.annotation.WebFilter;
import javax.servlet.annotation.WebInitParam;
import com.alibaba.druid.support.http.WebStatFilter;
/**
 * Druid的StatFilter
 *
 * @author   
 */
@WebFilter(filterName="druidWebStatFilter",urlPatterns="/*",
    initParams={
        @WebInitParam(name="exclusions",value="*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")// 忽略资源
})
public class DruidStatFilter extends WebStatFilter {
}

import javax.servlet.annotation.WebInitParam;
import javax.servlet.annotation.WebServlet;
import com.alibaba.druid.support.http.StatViewServlet;
/**
 * StatViewServlet
 *
 */
@SuppressWarnings("serial")
@WebServlet(urlPatterns = "/druid/*", 
    initParams={
            @WebInitParam(name="allow",value="192.168.16.110,127.0.0.1"),// IP白名单 (没有配置或者为空，则允许所有访问)
            @WebInitParam(name="deny",value="192.168.16.111"),// IP黑名单 (存在共同时，deny优先于allow)
            @WebInitParam(name="loginUsername",value="admin"),// 用户名
            @WebInitParam(name="loginPassword",value="admin"),// 密码
            @WebInitParam(name="resetEnable",value="false")// 禁用HTML页面上的“Reset All”功能
    })
public class DruidStatViewServlet extends StatViewServlet {
}

@ControllerAdvice

@ExceptionHandler

import javax.servlet.http.HttpServletRequest;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
@ControllerAdvice
@ResponseBody
public class GlobalExceptionHandler {
    /**
     * 所有异常报错
     * @param request
     * @param exception
     * @return
     * @throws Exception
     */
    @ExceptionHandler(value=Exception.class)  
    public String allExceptionHandler(HttpServletRequest request,  
            Exception exception) throws Exception  
    {  
        exception.printStackTrace();
        System.out.println("我报错了："+exception.getLocalizedMessage());
        System.out.println("我报错了："+exception.getCause());
        System.out.println("我报错了："+exception.getSuppressed());
        System.out.println("我报错了："+exception.getMessage());
        System.out.println("我报错了："+exception.getStackTrace());
        return "服务器异常，请联系管理员！";  
    }  
}

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.alibaba.fastjson.support.config.FastJsonConfig;
import com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter4;
import com.company.project.core.Result;
import com.company.project.core.ResultCode;
import com.company.project.core.ServiceException;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.NoHandlerFoundException;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter {
    private final Logger logger = LoggerFactory.getLogger(WebMvcConfigurer.class);
    @Value("${spring.profiles.active}")
    private String env;//当前激活的配置文件
    //使用阿里 FastJson 作为JSON MessageConverter
    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        FastJsonHttpMessageConverter4 converter = new FastJsonHttpMessageConverter4();
        FastJsonConfig config = new FastJsonConfig();
        config.setSerializerFeatures(SerializerFeature.WriteMapNullValue,//保留空的字段
                SerializerFeature.WriteNullStringAsEmpty,//String null -> ""
                SerializerFeature.WriteNullNumberAsZero);//Number null -> 0
        converter.setFastJsonConfig(config);
        converter.setDefaultCharset(Charset.forName("UTF-8"));
        converters.add(converter);
    }
    //统一异常处理
    @Override
    public void configureHandlerExceptionResolvers(List<HandlerExceptionResolver> exceptionResolvers) {
        exceptionResolvers.add(new HandlerExceptionResolver() {
            public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception e) {
                Result result = new Result();
                if (e instanceof ServiceException) {//业务失败的异常，如“账号或密码错误”
                    result.setCode(ResultCode.FAIL).setMessage(e.getMessage());
                    logger.info(e.getMessage());
                } else if (e instanceof NoHandlerFoundException) {
                    result.setCode(ResultCode.NOT_FOUND).setMessage("接口 [" + request.getRequestURI() + "] 不存在");
                } else if (e instanceof ServletException) {
                    result.setCode(ResultCode.FAIL).setMessage(e.getMessage());
                } else {
                    result.setCode(ResultCode.INTERNAL_SERVER_ERROR).setMessage("接口 [" + request.getRequestURI() + "] 内部错误，请联系管理员");
                    String message;
                    if (handler instanceof HandlerMethod) {
                        HandlerMethod handlerMethod = (HandlerMethod) handler;
                        message = String.format("接口 [%s] 出现异常，方法：%s.%s，异常摘要：%s",
                                request.getRequestURI(),
                                handlerMethod.getBean().getClass().getName(),
                                handlerMethod.getMethod().getName(),
                                e.getMessage());
                    } else {
                        message = e.getMessage();
                    }
                    logger.error(message, e);
                }
                responseResult(response, result);
                return new ModelAndView();
            }
        });
    }
    //解决跨域问题
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        //registry.addMapping("/**");
    }
    //添加拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //接口签名认证拦截器，该签名认证比较简单，实际项目中可以使用Json Web Token或其他更好的方式替代。
        if (!"dev".equals(env)) { //开发环境忽略签名认证
            registry.addInterceptor(new HandlerInterceptorAdapter() {
                @Override
                public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                    //验证签名
                    boolean pass = validateSign(request);
                    if (pass) {
                        return true;
                    } else {
                        logger.warn("签名认证失败，请求接口：{}，请求IP：{}，请求参数：{}",
                                request.getRequestURI(), getIpAddress(request), JSON.toJSONString(request.getParameterMap()));
                        Result result = new Result();
                        result.setCode(ResultCode.UNAUTHORIZED).setMessage("签名认证失败");
                        responseResult(response, result);
                        return false;
                    }
                }
            });
        }
    }
    private void responseResult(HttpServletResponse response, Result result) {
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Content-type", "application/json;charset=UTF-8");
        response.setStatus(200);
        try {
            response.getWriter().write(JSON.toJSONString(result));
        } catch (IOException ex) {
            logger.error(ex.getMessage());
        }
    }
    /**
     * 一个简单的签名认证，规则：
     * 1. 将请求参数按ascii码排序
     * 2. 拼接为a=value&b=value...这样的字符串（不包含sign）
     * 3. 混合密钥（secret）进行md5获得签名，与请求的签名进行比较
     */
    private boolean validateSign(HttpServletRequest request) {
        String requestSign = request.getParameter("sign");//获得请求签名，如sign=19e907700db7ad91318424a97c54ed57
        if (StringUtils.isEmpty(requestSign)) {
            return false;
        }
        List<String> keys = new ArrayList<String>(request.getParameterMap().keySet());
        keys.remove("sign");//排除sign参数
        Collections.sort(keys);//排序
        StringBuilder sb = new StringBuilder();
        for (String key : keys) {
            sb.append(key).append("=").append(request.getParameter(key)).append("&");//拼接字符串
        }
        String linkString = sb.toString();
        linkString = StringUtils.substring(linkString, 0, linkString.length() - 1);//去除最后一个'&'
        String secret = "Potato";//密钥，自己修改
        String sign = DigestUtils.md5Hex(linkString + secret);//混合密钥md5
        return StringUtils.equals(sign, requestSign);//比较
    }
    private String getIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_CLIENT_IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("HTTP_X_FORWARDED_FOR");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        // 如果是多级代理，那么取第一个ip为客户端ip
        if (ip != null && ip.indexOf(",") != -1) {
            ip = ip.substring(0, ip.indexOf(",")).trim();
        }
        return ip;
    }
}

Server-id = 2 #这里ID改为2 因为主库为1;
log-bin = mysql-bin  ####必填项，用于数据同步 ; 
master-host = 192.168.1.60  ####主库IP;
master-user = test  ####同步用的账户;
master-password = 123456  ####同步账户密码，主库时的设置;
master-port = 3306 ##同步数据库的端口号。

下面演示dataX 
配置示例：从MySQL读取数据 写入MYSQL
（liunx/centos7） 各位学习的童鞋可以自己安装一个VM安装一个liunx系统
演示条件
mysql_reader 47.93.226.82:3606
mysql_writer 47.93.226.82:3605
安装mysql (作者docker安装mysql )
docker run -p ip:ip --name mymysql -v $PWD/conf/my.cnf:/etc/mysql/my.cnf -v $PWD/logs:/logs -v $PWD/data:/mysql_data -e MYSQL_ROOT_PASSWORD=123456 -d imageid 
-v 是挂载目录
-p 是开放端口

   {
    "job": {
        "content": [
            {
                "reader": {
                    "name": "mysqlreader", 
                    "parameter": {
                        "column": ["id","real_name"], 
                        "connection": [
                            {
                    
							 "jdbcUrl": [
                                    "jdbc:mysql://47.93.226.82:3306/test"
                                ],
                                "table": ["t_ur_user_m"]
                            }
                        ], 
                        "password": "####", 
                        "username": "dev@####"
                    }
                }, 
                "writer": {
                    "name": "mysqlwriter", 
                    "parameter": {
                         "column": ["id","real_name"], 
                        "connection": [
                            {
								"jdbcUrl": "jdbc:mysql://47.93.226.82:3307/test?characterEncoding=utf-8",
                                "table": ["datax_user"]
                            }
                        ], 
                        "password": "####", 
                        "username": "dev@####"
                    }
                }
            }
           
            
        ], 
        "setting": {
            "speed": {
                "channel": "2"
            }
        }
    }
}

$ cd {YOUR_DATAX_DIR_BIN}
$ python datax.py ./mysql2odps.json 
同步结束，显示日志如下：
...
2015-12-17 11:20:25.263 [job-0] INFO  JobContainer - 
任务启动时刻                    : 2015-12-17 11:20:15
任务结束时刻                    : 2015-12-17 11:20:25
任务总计耗时                    :                 10s
任务平均流量                    :              205B/s
记录写入速度                    :              5rec/s
读出记录总数                    :                  50
读写失败总数                    :                   0

前置条件：安装crond服务,并已启动
#查看crond服务是否启动，出现以下日志表示已启动
$/sbin/service crond status
 crond (pid  30742) is running...