作为一个web开发者，根据产品经理的需求来完成一个应用显然不是我们的唯一目标，很多时候，我们考虑的不仅仅是需求，而是超越需求，认识到项目上线后的性能瓶颈。很多web应用在上线后，都可能会碰到响应慢的问题，而从今天开始，我将以浅显的例子带领大家一步一步的优化web应用。
先举个栗子：
小白在做一个web列表页时，需求很简单，当用户访问第一个页的时候，服务器返回1-10条的文章简介数据，访问第2页的时候，服务器返回11-20条的文章简介数据。小白转念一想，这简单啊，每次前端给我一个页数就行，我直接从数据库中查出来，然后返回回去就行。哈哈，so easy!
当小白把程序写好上线后，随着用户以及文章的增多，数据库的压力也越大，比如当文章数量达到一百万条时，每次分页查询都需要耗时数据库500ms左右，这时候小白就意识到程序需要优化了。
这时候小白的老师来了，老师说，这些文章列表数据，在短时间中不会改变太大，为什么不把它缓存起来呢？这样每次都可以从内存中取出来，而不用每次都访问数据库了。
即项目架构由最简单的
加入了cache层：
这样，可以极大的加快访问速度。
就拿这个例子来说，你可以把每次获取的列表信心都缓存起来，为了在缓存的同时也能保持更新，你可以设置列表缓存为1分钟过期，这样这1分钟内多次访问速度会极大的提高。
Redis 是一个高性能的key-value数据库。可以对关系数据库起到很好的补充作用。
小白在听了老师给出的建议后，马上着手开始搭建redis开发环境，并开始开发，他写了一个demo，这个demo中，使用缓存前每次访问的速度为400-500ms，使用缓存后的访问速度稳定在25-27ms，相当于17倍的速度提升！
下面为主要的测试代码：
[java] view plain copy
1. package com.happyheng.controller;
2.
3. import com.alibaba.fastjson.JSON;
4. import com.happyheng.dao.ArticleDao;
5. import com.happyheng.model.Article;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.util.StringUtils;
8. import org.springframework.web.bind.annotation.RequestMapping;
9. import org.springframework.web.bind.annotation.RestController;
10. import redis.clients.jedis.Jedis;
11.
12. import java.util.List;
13.
14. /**
15. *
16. *
17. * Created by happyheng on 17/5/6.
18. */
19. @RestController
20. @RequestMapping("/test")
21. public class TestController {
22.
23.
24. private static final String KEY_CACHE_ARTICLE_LIST = "article_list";
25.
26. @Autowired
27. private ArticleDao articleDao;
28.
29.
30. @RequestMapping("/testSelectFromDb")
31. public List<Article> testSelectFromDb() throws Exception {
32.
33. return articleDao.getArticleListFromdb();
34. }
35.
36. @RequestMapping("/testSelectFromCache")
37. public String testSelectFromCache() throws Exception {
38.
39. Jedis jedis = new Jedis("localhost");
40. // 先从缓存中取出数据
41. String articleListStr = jedis.get(KEY_CACHE_ARTICLE_LIST);
42. if (!StringUtils.isEmpty(articleListStr)) {
43.
44. return articleListStr;
45. } else {
46.
47. // 如果数据为空,那么从db中取出来,然后序列化后写入到cache中,并设置1分钟的过期时间
48. List<Article> articleList = articleDao.getArticleListFromdb();
49. String serializeArticleListStr = JSON.toJSONString(articleList);
50. jedis.set(KEY_CACHE_ARTICLE_LIST, serializeArticleListStr);
51. jedis.expire(KEY_CACHE_ARTICLE_LIST, 60);
52. return serializeArticleListStr;
53. }
54.
55. }
56.
57.
58. }[java] view plain copy
1. package com.happyheng.dao;
2.
3. import com.happyheng.model.Article;
4. import org.springframework.stereotype.Service;
5.
6. import java.sql.*;
7. import java.util.ArrayList;
8. import java.util.List;
9.
10. /**
11. *
12. *
13. * Created by happyheng on 17/5/7.
14. */
15. @Service
16. public class ArticleDao {
17.
18.
19. public List<Article> getArticleListFromdb() throws Exception{
20.
21. String sql = "SELECT * FROM article ORDER BY create_time DESC LIMIT 0, 10";
22.
23. Class.forName("com.mysql.jdbc.Driver");
24. Connection mConnection = DriverManager.getConnection("jdbc:mysql://localhost:3306/optimize_db", "root", "mytestcon");
25. Statement statement = mConnection.createStatement();
26. ResultSet resultSet = statement.executeQuery(sql);
27.
28. try {
29. List<Article> list = new ArrayList<>();
30. //注意指针刚开始是-1位置，这行next()方法，会先判断下一个位置有没有，如果有，指向下一个位置。
31. while (resultSet.next()) {
32. Article article = new Article();
33. article.setId(resultSet.getLong("id"));
34. article.setTitle(resultSet.getString("title"));
35. article.setContent(resultSet.getString("content"));
36. article.setCreate_time(resultSet.getString("create_time"));
37. list.add(article);
38. }
39. return list;
40. } catch (Exception e) {
41. e.printStackTrace();
42. } finally {
43. try {
44. resultSet.close();
45. statement.close();
46. mConnection.close();
47. } catch (SQLException e) {
48. e.printStackTrace();
49. }
50.
51. }
52.
53. return null;
54. }
55. }可以看到，当访问 testSelectFromDb 时，直接从数据库中获取数据，访问 testSelectFromCache 时，先从cache中获取数据，如果没有，从数据库中获取数据，然后写入到cache中，下面为两种访问方法的访问时间对比：
直接访问db：
访问cache：
转载于:https://blog.51cto.com/12879205/1923339
