taotao单点登录的用户Controller、service（注册、登录、验证是否登录方法）

接口文档：

1.1. 注册接口

1.1.1. 检查数据是否可用

请求方法	GET
URL	http://sso.taotao.com/user/check/{param}/{type}
参数说明	格式如：zhangsan/ 1，其中zhangsan是校验的数据，type为类型，可选参数1、2、3分别代表username、phone、email 可选参数callback：如果有此参数表示此方法为jsonp请求，需要支持jsonp。
示例	http://sso.taotao.com/user/check/zhangsan/1
返回值	{ status: 200 //200 成功 msg: "OK" // 返回信息消息 data: false // 返回数据，true：数据可用，false：数据不可用 }

1.1.2. 用户注册

请求方法	POST
URL	http://sso.taotao.com/user/register
参数	username //用户名 password //密码 phone //手机号 email //邮箱
参数说明
示例	http://sso.taotao.com/user/register
返回值	{ status: 400 msg: "注册失败. 请校验数据后请再提交数据." data: null }

1.2. 用户登录

请求方法	POST
URL	http://sso.taotao.com/user/login
参数	username //用户名 password //密码
参数说明
示例	http://sso.taotao.com/user/login username=zhangsan&password=123
返回值	{ status: 200 msg: "OK" data: "fe5cb546aeb3ce1bf37abcb08a40493e" //登录成功，返回token }

1.3. 通过token查询用户信息

请求方法	GET
URL	http://sso.taotao.com/user/token/{token}
参数	token //用户登录凭证 callback//jsonp回调方法
参数说明	可选参数callback：如果有此参数表示此方法为jsonp请求，需要支持jsonp。
示例	http://sso.taotao.com/user/token/fe5cb546aeb3ce1bf37abcb08a40493e
返回值	{ status: 200 msg: "OK" data: "{"id":1,"username":"zhangzhijun","phone":"15800807944", "email":"420840806@qq.com","created":1414119176000,"updated":1414119179000}" }

1.4. 安全退出

请求方法	GET
URL	http://sso.taotao.com/user/logout/{token}
参数	token //用户登录凭证 callback//jsonp回调方法
参数说明	可选参数callback：如果有此参数表示此方法为jsonp请求，需要支持jsonp。
示例	http://sso.taotao.com/user/logout/fe5cb546aeb3ce1bf37abcb08a40493e
返回值	{ status: 200 msg: "OK" data: "" }

Controller：

package com.taotao.sso.controller;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.converter.json.MappingJacksonValue;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.taotao.common.pojo.TaotaoResult;
import com.taotao.common.utils.ExceptionUtil;
import com.taotao.pojo.TbUser;
import com.taotao.sso.service.UserService;

@Controller
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

/**校验用户名、电话、邮箱是否重复方法
* 接口文档:
* 请求方法    GET
URL    http://sso.taotao.com/user/check/{param}/{type}
参数说明
格式如：zhangsan/ 1，其中zhangsan是校验的数据，type为类型，可选参数1、2、3分别代表username、phone、email

可选参数callback：如果有此参数表示此方法为jsonp请求，需要支持jsonp。
*/
    @RequestMapping("/check/{param}/{type}")
    @ResponseBody
    public Object checkData(@PathVariable String param,@PathVariable Integer type,String callback){
        //返回结果
        TaotaoResult result = null;
        //校验参数是否正确（注意：在Controller中校验即可，service中可以不校验了）
        if (StringUtils.isEmpty(param)) {
            result = TaotaoResult.build(400, "校验内容不能为空");
        }
        if (type==null) {
            result = TaotaoResult.build(400, "校验内容参数不能为空");
        }
        if (1!=type && 2!=type && 3!=type) {
            result = TaotaoResult.build(400, "校验内容类型错误");
        }
        //说明参数异常需要提前返回
        if (result!=null) {
            //判断是否需要支持jsonP
            if (callback!=null) {
                //需要将返回结果封装成支持jsonP的形式（注意:这种返回json支持的写法）
                MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(result);
                mappingJacksonValue.setJsonpFunction(callback);
                return mappingJacksonValue;
            }else{
                return result;
            }
        }
        //因为是提供接口服务，所以要处理可能出现的逻辑上的异常
        try {
            //调用service执行正常的业务逻辑
            result = userService.checkData(param, type);
        } catch (Exception e) {
            result = TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));
        }
        //正常返回也需要判断是否需要jsonP
        if (null!=callback) {
            MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(result);
            mappingJacksonValue.setJsonpFunction(callback);
            return mappingJacksonValue;
        }else{
            return result;
        }
    }

    //用户注册
    @RequestMapping("/register")
    @ResponseBody
    public TaotaoResult createUser(TbUser user) {
        try {
            TaotaoResult result = userService.createUser(user);
            return result;
        } catch (Exception e) {
            return TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));
        }
    }

    //用户登录
    @RequestMapping("/login")
    @ResponseBody
    public TaotaoResult userLogin(String username,String password){
        //因为是接口服务端，所以要try处理异常
        try {
            TaotaoResult result = userService.userLogin(username, password);
            return result;
        } catch (Exception e) {
            e.printStackTrace();
            return TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));
        }
    }

    //根据token获取用户信息（判断是否登录）
    @RequestMapping("/token/{token}")
    @ResponseBody
    public Object getUserByToken(@PathVariable String token,String callback){
        TaotaoResult result = null;
        try {
            result = userService.getUserByToken(token);
        } catch (Exception e) {
            e.printStackTrace();
            result = TaotaoResult.build(500, ExceptionUtil.getStackTrace(e));
        }
        //判断是否为jsonp调用
        if (StringUtils.isEmpty(callback)) {
            return result;
        }else{
            MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(result);
            mappingJacksonValue.setJsonpFunction(callback);
            return mappingJacksonValue;
        }
    }

}

Service:

package com.taotao.sso.service.impl;

import java.util.Date;
import java.util.List;
import java.util.UUID;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.propertyeditors.UUIDEditor;
import org.springframework.stereotype.Service;
import org.springframework.util.DigestUtils;

import com.taotao.common.pojo.TaotaoResult;
import com.taotao.common.utils.JsonUtils;
import com.taotao.mapper.TbUserMapper;
import com.taotao.pojo.TbUser;
import com.taotao.pojo.TbUserExample;
import com.taotao.pojo.TbUserExample.Criteria;
import com.taotao.sso.dao.JedisClient;
import com.taotao.sso.service.UserService;
/**
 * 用户管理的service
 * @author Administrator
 */
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private TbUserMapper userMapper;

    @Autowired
    private JedisClient jedisClient;

//    #用户session在redis中保存的key
    @Value("${REDIS_USER_SESSION_KEY}")
    private String REDIS_USER_SESSION_KEY;  //REDIS_USER_SESSION_KEY=REDIS_USER_SESSION

//    #session的过期时间30分钟
    @Value("${SSO_SESSION_EXPIRE}")
    private Integer SSO_SESSION_EXPIRE; //SSO_SESSION_EXPIRE=1800

    //校验用户名、电话、邮箱 是否不重复
    @Override
    public TaotaoResult checkData(String content, Integer type) {
        //创建查询对象
        TbUserExample example = new TbUserExample();
        Criteria criteria = example.createCriteria();
        //封装查询条件
        switch (type) {
        case 1:
            criteria.andUsernameEqualTo(content);
            break;
        case 2:
            criteria.andPhoneEqualTo(content);
            break;
        case 3:
            criteria.andEmailEqualTo(content);
            break;
        }
        //因为在Controller层中调用此接口前就已经校验过 type的值一定为123中的一个，所以这里不用再次校验了
        //执行查询
        List<TbUser> list = userMapper.selectByExample(example);
        if (list!=null && list.size()>0) {
            return TaotaoResult.ok(false);
        }
        return TaotaoResult.ok(true);
    }

    //用户注册
    @Override
    public TaotaoResult createUser(TbUser user) {
        user.setCreated(new Date());
        user.setUpdated(new Date());
        user.setPassword(DigestUtils.md5DigestAsHex(user.getPassword().getBytes()));
        userMapper.insert(user);
        return TaotaoResult.ok();
    }

    //用户登录
    @Override
    public TaotaoResult userLogin(String username, String password) {
        //和数据库中数据比对
        TbUserExample example = new TbUserExample();
        example.createCriteria().
        andUsernameEqualTo(username).
        andPasswordEqualTo(DigestUtils.md5DigestAsHex(password.getBytes()));
        List<TbUser> list = userMapper.selectByExample(example);
        if (list==null || list.size()==0) {
            return TaotaoResult.build(400, "用户名或密码错误");
        }
        //说明登录成功,获取用户对象
        TbUser user = list.get(0);
        //生成token，并把用户存入redis中
        //注意：这种生成uuid的方法（无需引入其他jar包，用的java.util包）
        String token = UUID.randomUUID().toString();
        //注意：存入redis中的用户信息的key 是  大分类 + ： +生成的 uuid,value 是用户的对象转json串
        String key = REDIS_USER_SESSION_KEY+":"+token;
        //为了安全，在存入用户信息前先将用户密码去掉
        user.setPassword(null);
        String userJson = JsonUtils.objectToJson(user);
        //将用户存入redis中
        jedisClient.set(key, userJson);
        //注意：这里用户登录后把用户信息及token存入redis是正常的业务逻辑，如果失败，需要整个方法回滚，所以不用单独try
        //设置过期时间
        jedisClient.expire(key, SSO_SESSION_EXPIRE);
        return TaotaoResult.ok(token);
    }

    //根据token判断用户是否为登录状态
    @Override
    public TaotaoResult getUserByToken(String token) {
        //拿token到redis中取用户信息  REDIS_USER_SESSION;:8d7b07f2-eb83-4446-bab4-bc1416727b5f
        String key = REDIS_USER_SESSION_KEY+":"+token;
        String json = jedisClient.get(key);
        //判断是否为空
        if (StringUtils.isEmpty(json)) {
            return TaotaoResult.build(400, "此session已经过期，请重新登录");
        }
        //并更新过期时间
        jedisClient.expire(key, SSO_SESSION_EXPIRE);
        //返回用户信息
        return TaotaoResult.ok(JsonUtils.jsonToPojo(json, TbUser.class));
    }
}