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

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;

        }

    }

}

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));

    }

}