emall商城-面向接口编程实践

1. 面向接口编程

在一个面向对象的系统中,系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下,
各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了;而各个对象之间的协作关
系则成为系统设计的关键。小到不同类之间的通信,大到各模块之间的交互,在系统设计之初都
是要着重考虑的,这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

上述内容来自百度百科(说实话我没看懂).

2. 需求

emall商城中有用户登录后需要将用户的token信息在服务端保存一份,实现这个功能有两个思路:

  • Redis
  • Guava的LoadingCache

此处就需要将存储token的这一逻辑抽象成接口,两种方式分别实现此接口,从而达到业务逻辑与底层实现分离.

3. 实现

3.1 抽象ILocalCache接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
* 本地缓存
* @author lujiahao
* @version 1.0
* @date 2017-10-20 17:24
*/
public interface ILocalCache<T> {
/**
* 设置缓存
* @param key
* @param value
* @return
*/
boolean setCache(String key, T value);

/**
* 删除缓存
* @param key
* @return
*/
boolean cleanCache(String key);

/**
* 获取缓存
* @param key
* @return
*/
Object getCache(String key);
}

3.2 Redis实现方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
* Redis实现缓存
* @author lujiahao
* @version 1.0
* @date 2017-10-20 17:33
*/
public class RedisCacheImpl<T> implements ILocalCache<T> {
public static final Logger LOGGER = LoggerFactory.getLogger(RedisCacheImpl.class);

@Autowired
private JedisClientDao jedisClientDao;

@Override
public boolean setCache(String key, T value) {
// 把用户信息写入redis
jedisClientDao.set(Const.CACHE_TOKEN + ":" + key, JsonUtils.objectToJson(value));
// 设置session过期时间
jedisClientDao.expire(Const.CACHE_TOKEN + ":" + key, Const.CACHE_TOKEN_EXPIRE);
return true;
}

@Override
public boolean cleanCache(String key) {
try {
// 根据token从redis中查询用户信息
String json = jedisClientDao.get(Const.CACHE_TOKEN + ":" + key);
if (StringUtils.isNoneBlank(json)) {
// 更新过期时间--清除key
jedisClientDao.expire(Const.CACHE_TOKEN + ":" + key, 0);
}
return true;
} catch (Exception e) {
return false;
}
}

@Override
public Object getCache(String key) {
try {
// 根据token从redis中查询用户信息
String json = jedisClientDao.get(Const.CACHE_TOKEN + ":" + key);
if (StringUtils.isBlank(json)) {
return ServerResponse.build(400, "此Session已经过期,请重新登录");
}
// 更新过期时间
jedisClientDao.expire(Const.CACHE_TOKEN + ":" + key, Const.CACHE_TOKEN_EXPIRE);
// 返回用户信息
EmallUser emallUser = JsonUtils.jsonToPojo(json, EmallUser.class);
return ServerResponse.success(emallUser);
} catch (Exception e) {
return ServerResponse.error("无法获取用户信息");
}
}
}

3.3 Guava的LoadingCache实现方式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
/**
* Guava实现缓存
* @author lujiahao
* @version 1.0
* @date 2017-10-20 17:33
*/
public class GuavaCacheImpl<T> implements ILocalCache<T> {
public static final Logger LOGGER = LoggerFactory.getLogger(GuavaCacheImpl.class);

// LRU算法
private static LoadingCache<String, Object> localCache = CacheBuilder.newBuilder().initialCapacity(1000)
.maximumSize(10000).expireAfterAccess(12, TimeUnit.HOURS)
.build(new CacheLoader<String, Object>() {
// 默认的数据加载实现,当调用get取值是,如果没有key,就执行这个方法
@Override
public Object load(String s) throws Exception {
return null;
}
});

@Override
public boolean setCache(String key, T value) {
try {
localCache.put(key, value);
} catch (Exception e) {
return false;
}
return true;
}

@Override
public boolean cleanCache(String key) {
try {
localCache.invalidate(key);
} catch (Exception e) {
return false;
}
return true;
}

@Override
public Object getCache(String key) {
try {
return localCache.get(key);
} catch (Exception e) {
LOGGER.error("========== localCache get error ==========", e);
}
return null;
}
}

3.4 applicationContext.xml中配置

1
2
3
<!--根据具体实现采用缓存实现方式-->
<!--<bean class="com.lujiahao.sso.utils.cache.RedisCacheImpl"/>-->
<bean class="com.lujiahao.sso.utils.cache.GuavaCacheImpl"/>

3.5 代码中使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
@Service
public class IUserServiceImpl implements IUserService {
private static final Logger LOGGER = LoggerFactory.getLogger(IUserServiceImpl.class);

@Autowired
private EmallUserMapper emallUserMapper;

@Autowired
private ILocalCache iLocalCache;

@Override
public ServerResponse userLogin(String username, String password) {
try {
String md5Password = DigestUtils.md5DigestAsHex(password.getBytes());
EmallUser emallUser = emallUserMapper.userLogin(username, md5Password);
if (emallUser == null) {
// 不能返回没有此用户名 没用用户名也返回这个信息是因为防止猜测用户名
return ServerResponse.error("用户名或密码错误");
}
// 保存用户信息前先把密码清除,为了安全起见
emallUser.setPassword(StringUtils.EMPTY);
String token = UUID.randomUUID().toString();
// 这里采用接口编程的方式,到底用redis还是用guava
boolean isSaveSuccess = iLocalCache.setCache(token, emallUser);
if (isSaveSuccess) {
return ServerResponse.success(token);
} else {
LOGGER.info("========== 用户信息保存缓存失败 ==========");
return ServerResponse.error("登录失败,请重试!");
}
} catch (Exception e) {
ExceptionUtil.getStackTrace(e);
return ServerResponse.error("服务器异常");
}
}
}

在代码中使用的时候,将接口ILocalCache注入,在applicationContex.xml中根据具体要求配置不同的
bean,由此就可以实现将缓存业务与缓存实现解耦.

4. 总结

我理解的面向接口编程就是将业务中的需求抽取出公共的几种方式或步骤,底层由不同的类来实现这个接口,
由此达到解耦的目的.个人理解,欢迎大家拍砖^_^.

emall商城-SSO单点登录

1. 前期准备

  1. 准备一台Redis服务器
  2. 添加host127.0.0.1 sso.emall.com
  3. 搭建emall-sso工程并整合响应的框架

2. 实现原理

单点登录的场景随处可见,此功能极大的简化了用户在网站间的重复登录,使得用户体验更加良好.本教程单点登录的实现原理:用户根据用户名和密码登录,成功后服务器返回token信息,并将token信息写入Redis和Cookie中,用户再次登录时,首先判断Cookie中是否有token信息,如果有则根据token去后台换取用户信息;否则提示用户重新登录.

3. 实现步骤

3.1 登录接口

/**
 * 用户登录
 */
@Override
public CommonResult userLogin(UserDTO userDTO, HttpServletRequest request, HttpServletResponse response) {
    String username = userDTO.getUsername();
    String password = userDTO.getPassword();

    TbUserExample example = new TbUserExample();
    TbUserExample.Criteria criteria = example.createCriteria();
    criteria.andUsernameEqualTo(username);
    List<TbUser> list = tbUserMapper.selectByExample(example);
    // 如果没有此用户名  没用用户名也返回这个信息是因为防止猜测用户名
    if (list == null || list.size() == 0) {
        return CommonResult.build(400, "用户名或密码错误");
    }
    TbUser tbUser = list.get(0);
    // 对比密码
    if (!DigestUtils.md5DigestAsHex(password.getBytes()).equals(tbUser.getPassword())) {
        return CommonResult.build(400, "用户名或密码错误");
    }
    // 生成token
    String token = UUID.randomUUID().toString();
    // 保存用户信息前先把密码清除,为了安全起见
    tbUser.setPassword(null);

    // 用户信息存入Redis
    saveUserInfoToRedis(tbUser, token);

    // 添加写cookie的逻辑  cookie有效期是关闭浏览器失效
    CookieUtils.setCookie(request, response, COOKIE_TOKEN, token);
    return CommonResult.ok(token);
}

3.2 根据token查询用户信息

/**
 * 根据token查询用户信息
 */
@Override
public CommonResult getUserByToken(String token) {
    // 根据token从redis中查询用户信息
    String json = jedisClientDao.get(REDIS_USER_SESSION_KEY + ":" + token);
    if (StringUtils.isBlank(json)) {
        return CommonResult.build(400, "此Session已经过期,请重新登录");
    }
    // 更新过期时间
    jedisClientDao.expire(REDIS_USER_SESSION_KEY + ":" + token, SSO_SESSION_EXPIRE);
    // 返回用户信息
    return CommonResult.ok(JsonUtils.jsonToPojo(json, TbUser.class));
}

4. 跨域

4.1 JSONP

JSONP的实现与 ajax 没有任何关系,JSONP是通过script的src实现的,最终都是向服务器发送请求数据然后回调,而且方便起见,jquery把 JSONP 封装在了 $.ajax 方法中,调用方式与 ajax 调用方式略有区别。JSONP本质是:动态创建script标签,然后通过他的src属性发送跨域请求.

/**
 * 通过token查询用户信息
 *
 * @param token
 * @return
 */
@RequestMapping(value = "/token/{token}")
@ResponseBody
public Object getUserByToken(@PathVariable String token, String callback) {
    CommonResult result = null;
    try {
        result = userService.getUserByToken(token);
    } catch (Exception e) {
        e.printStackTrace();
        result = CommonResult.build(500, ExceptionUtil.getStackTrace(e));
    }
    // 判断是否为jsonp调用
    if (StringUtils.isBlank(callback)) {
        // 不是jsonp调用
        return result;
    } else {
        MappingJacksonValue mappingJacksonValue = new MappingJacksonValue(result);
        mappingJacksonValue.setJsonpFunction(callback);
        return mappingJacksonValue;
    }
}

4.2 CORS

此种方式后端实现有两种方式:
    让所有的controller类继承自定义的BaseController类,改类中将对返回的头部做些特殊处理;
    通过filter实现所有的请求封装跨域.

4.2.1 继承BaseController

public abstract class BaseController {
      /**
     * description:send the ajax response back to the client side
     * @param responseObj
     * @param response
     */
    protected void writeAjaxJSONResponse(Object responseObj, HttpServletResponse response) {
        response.setCharacterEncoding("UTF-8");
        response.setHeader("Cache-Control", "no-cache, no-store, must-revalidate"); // HTTP 1.1
        response.setHeader("Pragma", "no-cache"); // HTTP 1.0
        /**
         * for ajax-cross-domain request TODO get the ip address from
         * configration(ajax-cross-domain.properties)
         */
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setDateHeader("Expires", 0); // Proxies.
        PrintWriter writer = getWriter(response);
        writeAjaxJSONResponse(responseObj, writer);
    }

      /**
     *
     * @param response
     * @return
     */
    protected PrintWriter getWriter(HttpServletResponse response) {
        if(null == response){
            return null;
        }
        PrintWriter writer = null;
        try {
            writer = response.getWriter();
        } catch (IOException e) {
            logger.error("unknow exception", e);
        }
        return writer;
    }

    /**
     * description:send the ajax response back to the client side.
     *
     * @param responseObj
     * @param writer
     * @param writer
     */
    protected void writeAjaxJSONResponse(Object responseObj, PrintWriter writer) {
        if (writer == null || responseObj == null) {
            return;
        }
        try {         
            writer.write(JSON.toJSONString(responseObj,SerializerFeature.DisableCircularReferenceDetect));
        } finally {
            writer.flush();
            writer.close();
        }
    }
}

4.2.2 Filter实现

/**
 * @author lujiahao
 * @version 1.0
 * @date 2017-10-15 22:20
 */
public class HeadersCORSFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        response.setHeader("Access-Control-Allow-Origin","*");
        filterChain.doFilter(servletRequest, response);
    }

    @Override
    public void destroy() {

    }
}

web.xml中配置:

<!-- Ajax Access-Control-Allow-Origin 跨域 拦截器解决方案 -->
<filter>
    <filter-name>ACAOFilter</filter-name>
    <filter-class>com.lujiahao.sso.filter.HeadersCORSFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>ACAOFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

5. 代码详见emall-sso

6. 实现效果

7. 说明

emall商城系列是整合[淘淘商城]和[慕课网Java从零到企业级电商项目实战]的系列,这两部教程来自互联网.