缓存（本地缓存）

在实际项目开发中，会使用到很多缓存技术，而且数据库的设计一般也会依赖于有缓存的情况下设计。

• 常用的缓存分两种：本地缓存和分布式缓存。
• 常用的本地缓存是guava cache，本文主要介绍guava cache在项目中的使用，首先来了解下为什么使用缓存，以数据库（如MYSQL）、本地缓存（如guava cache）及分布式缓存（如redis）的区别来讲：

一、数据库、本地缓存及分布式缓存的区别

1、存储位置：

• 数据库:任何机器硬盘，开关机时，数据不丢失
• 本地缓存：本机内存，一旦关机，之前的数据丢失
• 分布式缓存（如redis）：存在redis所在机器的内存，一旦redis所在机器关机，数据丢失

2、持久化：

• 数据库:可以持久化
• 本地缓存：不可以持久化
• 分布式缓存（如redis）：不可以持久化

3、访问速度：

• 数据库:慢
• 本地缓存：最快
• 分布式缓存：快

4、扩展性：

• 数据库:可扩展，可存在其他机器的硬盘
• 本地缓存：不可扩展，只能存在本机内存
• 分布式缓存：可扩展，可存在其他机器的内存

5、使用场景：

• 数据库:需要实现持久化保存
• 本地缓存：需要快速访问，但需要考虑内存大小
• 分布式缓存：1）需要快速访问，不需要考虑内存大小

                         2）需要实现持久化，但会丢失一些数据

                         3）需要让缓存集中在一起，访问任一机器上内存中的数据都可以从缓存中得到

二、实例

     基于SSMM框架整合步骤，连接（SSMM（spring+springmvc+maven+mybatis）框架整合）的flowershop项目。

1、启动MYSQL

2、创建mvn项目

• 配置pom.xml文件（这里直接给出已经配置好的）
• 

    1 xml version="1.0" encoding="UTF-8"?>
    2 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    4 
    5     <modelVersion>4.0.0modelVersion>
    6 
    7     <groupId>com.wngroupId>
    8     <artifactId>flowershopartifactId>
    9     <version>1.0-SNAPSHOTversion>
   10     <name>flowershopname>
   11     <packaging>warpackaging>
   12     <properties>
   13         <java.version>1.8java.version>
   14         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
   15         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
   16         <spring.version>4.2.4.RELEASEspring.version>
   17         <mybatis.version>3.2.8mybatis.version>
   18         <mybatis-spring.version>1.2.2mybatis-spring.version>
   19         <jackson.version>2.6.4jackson.version>
   20         <servlet-api.version>3.1.0servlet-api.version>
   21     properties>
   22     <dependencies>
   23         
   24         <dependency>
   25             <groupId>javax.servletgroupId>
   26             <artifactId>javax.servlet-apiartifactId>
   27             <version>${servlet-api.version}version>
   28             <scope>providedscope>
   29         dependency>
   30         
   31         <dependency>
   32             <groupId>org.springframeworkgroupId>
   33             <artifactId>spring-coreartifactId>
   34             <version>${spring.version}version>
   35         dependency>
   36         <dependency>
   37             <groupId>org.springframeworkgroupId>
   38             <artifactId>spring-beansartifactId>
   39             <version>${spring.version}version>
   40         dependency>
   41         <dependency>
   42             <groupId>org.springframeworkgroupId>
   43             <artifactId>spring-contextartifactId>
   44             <version>${spring.version}version>
   45         dependency>
   46         
   47         <dependency>
   48             <groupId>org.springframeworkgroupId>
   49             <artifactId>spring-webartifactId>
   50             <version>${spring.version}version>
   51         dependency>
   52         <dependency>
   53             <groupId>org.springframeworkgroupId>
   54             <artifactId>spring-webmvcartifactId>
   55             <version>${spring.version}version>
   56         dependency>
   57         
   58         <dependency>
   59             <groupId>org.springframeworkgroupId>
   60             <artifactId>spring-jdbcartifactId>
   61             <version>${spring.version}version>
   62         dependency>
   63         
   64         <dependency>
   65             <groupId>mysqlgroupId>
   66             <artifactId>mysql-connector-javaartifactId>
   67             <version>5.1.27version>
   68             <scope>runtimescope>
   69         dependency>
   70         
   71         <dependency>
   72             <groupId>org.apache.tomcatgroupId>
   73             <artifactId>tomcat-jdbcartifactId>
   74             <version>7.0.47version>
   75         dependency>
   76         
   77         <dependency>
   78             <groupId>org.mybatisgroupId>
   79             <artifactId>mybatisartifactId>
   80             <version>${mybatis.version}version>
   81         dependency>
   82         
   83         <dependency>
   84             <groupId>org.mybatisgroupId>
   85             <artifactId>mybatis-springartifactId>
   86             <version>${mybatis-spring.version}version>
   87         dependency>
   88         
   89         <dependency>
   90             <groupId>com.fasterxml.jackson.coregroupId>
   91             <artifactId>jackson-annotationsartifactId>
   92             <version>${jackson.version}version>
   93         dependency>
   94         <dependency>
   95             <groupId>com.fasterxml.jackson.coregroupId>
   96             <artifactId>jackson-coreartifactId>
   97             <version>${jackson.version}version>
   98         dependency>
   99         <dependency>
  100             <groupId>com.fasterxml.jackson.coregroupId>
  101             <artifactId>jackson-databindartifactId>
  102             <version>${jackson.version}version>
  103         dependency>
  104         
  105         <dependency>
  106             <groupId>com.google.guavagroupId>
  107             <artifactId>guavaartifactId>
  108             <version>14.0.1version>
  109         dependency>
  110     dependencies>
  111     <build>
  112         <plugins>
  113             <plugin>
  114                 <groupId>org.apache.maven.pluginsgroupId>
  115                 <artifactId>maven-compiler-pluginartifactId>
  116                 <configuration>
  117                     <source>1.8source>
  118                     <target>1.8target>
  119                     <encoding>utf-8encoding>
  120                 configuration>
  121             plugin>
  122         plugins>
  123     build>
  124 project>

  View Code

  这里用到guava cache，所以别忘了引入依赖guava cache

• 1               
  2         <dependency>
  3             <groupId>com.google.guavagroupId>
  4             <artifactId>guavaartifactId>
  5             <version>14.0.1version>
  6         dependency>

•  引入mysql库配置（src/main/resources）

  jdbc.properties

1 jdbc.driverClassName = com.mysql.jdbc.Driver
2 jdbc.url = jdbc:mysql://localhost:3306/wn
3 jdbc.username = root
4 jdbc.password = 123456

• 引入spring配置文件（src/main/resources）

        spring.xml

• 

   1 xml version="1.0" encoding="UTF-8"?>
   2 <beans xmlns="http://www.springframework.org/schema/beans"
   3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
   4     xmlns:mvc="http://www.springframework.org/schema/mvc"
   5     xsi:schemaLocation="http://www.springframework.org/schema/beans 
   6                            http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
   7                            http://www.springframework.org/schema/context 
   8                            http://www.springframework.org/schema/context/spring-context-3.2.xsd
   9                            http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd">
  10 
  11     
  12     <context:component-scan base-package="com.wn" />
  13     
  14     <mvc:annotation-driven />
  15     
  16     <context:property-placeholder location="classpath:jdbc.properties" />
  17 
  18     
  19     <bean id="flowerDataSource" class="org.apache.tomcat.jdbc.pool.DataSource"
  20         destroy-method="close">
  21         <property name="driverClassName" value="${jdbc.driverClassName}" />
  22         <property name="url" value="${jdbc.url}" />
  23         <property name="username" value="${jdbc.username}" />
  24         <property name="password" value="${jdbc.password}" />
  25     bean>
  26 
  27     
  28     <bean id="flowerSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  29         <property name="dataSource" ref="flowerDataSource" />
  30         <property name="mapperLocations">
  31             <list>
  32                 <value>classpath*:mapper/*Mapper.xmlvalue>
  33             list>
  34         property>
  35     bean>
  36     <bean id="flowerMapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  37         <property name="basePackage" value="com.wn.mapper" />
  38         <property name="sqlSessionFactoryBeanName" value="flowerSqlSessionFactory" />
  39     bean>
  40 beans>

  View Code

• 创建基本包（package）结构（controller、service、dao、mapper、model）

• 创建src/main/resources/mapper的folder包，用于放置*Mapper.xml

• 配置web.xml，使spring生效

• 

   1 xml version="1.0" encoding="utf-8"?>
   2 <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
   3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   4     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
   5     <servlet>
   6         <servlet-name>dispatcherServletservlet-name>
   7         <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
   8         <init-param>
   9             <param-name>contextConfigLocationparam-name>
  10             <param-value>classpath*:spring*.xmlparam-value>
  11         init-param>
  12         <load-on-startup>1load-on-startup>
  13     servlet>
  14     <servlet-mapping>
  15         <servlet-name>dispatcherServletservlet-name>
  16         <url-pattern>/url-pattern>
  17     servlet-mapping>
  18 
  19     <filter>
  20         <filter-name>encodingFilterfilter-name>
  21         <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
  22         <init-param>
  23             <param-name>encodingparam-name>
  24             <param-value>UTF-8param-value>
  25         init-param>
  26         <init-param>
  27             <param-name>forceEncodingparam-name>
  28             <param-value>trueparam-value>
  29         init-param>
  30     filter>
  31     <filter-mapping>
  32         <filter-name>encodingFilterfilter-name>
  33         <url-pattern>/*url-pattern>
  34     filter-mapping>
  35    web-app>

  View Code

3、使用mybatis-generator创建mybatis的xml文件、mapper层接口、model层

• 将生成的类、接口、xml拷贝到项目中
• FlowerMapper.xml
• 

    1 xml version="1.0" encoding="UTF-8" ?>
    2 DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
    3 <mapper namespace="com.wn.mapper.FlowerMapper">
    4     <resultMap id="BaseResultMap" type="com.wn.model.Flower">
    5         <id column="id" property="id" jdbcType="INTEGER" />
    6         <result column="type" property="type" jdbcType="VARCHAR" />
    7         <result column="colour" property="colour" jdbcType="VARCHAR" />
    8         <result column="number" property="number" jdbcType="INTEGER" />
    9         <result column="price" property="price" jdbcType="DECIMAL" />
   10         <result column="florescence" property="florescence" jdbcType="INTEGER" />
   11     resultMap>
   12     <sql id="Base_Column_List">
   13         id, type, colour, number, price, florescence
   14     sql>
   15     <select id="selectByPrimaryKey" resultMap="BaseResultMap"
   16         parameterType="java.lang.Integer">
   17         select
   18         <include refid="Base_Column_List" />
   19         from t_flower
   20         where id = #{id,jdbcType=INTEGER}
   21     select>
   22     <select id="selectByColour" resultMap="BaseResultMap"
   23         parameterType="java.lang.String">
   24         select
   25         <include refid="Base_Column_List" />
   26         from t_flower
   27         where colour=#{colour,jdbcType=VARCHAR}
   28     select>
   29               
   30     <select id="selectByCondition" resultMap="BaseResultMap"
   31         parameterType="java.lang.Integer">
   32         select
   33         <include refid="Base_Column_List" />
   34         from t_flower
   35         <where>
   36             <if test="type!=null">
   37                 type=#{type,jdbcType=VARCHAR}
   38             if>
   39             <if test="colour!=null">
   40                 AND colour=#{colour,jdbcType=VARCHAR}
   41             if>
   42             <if test="number!=null">
   43                 AND number=#{number,jdbcType=INTEGER}
   44             if>
   45             <if test="price!=null">
   46                 AND price=#{price,jdbcType=DECIMAL}
   47             if>
   48             <if test="florescence!=null">
   49                 AND florescence=#{florescence,jdbcType=INTEGER}
   50             if>
   51         where>
   52         
   53     select>
   54     <select id="selectLimit" resultMap="BaseResultMap"
   55         parameterType="java.lang.Integer">
   56         select
   57         <include refid="Base_Column_List" />
   58         from t_flower
   59         order by price DESC limit #{start}, #{size}
   60     select>
   61     <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
   62         delete from
   63         t_flower
   64         where id = #{id,jdbcType=INTEGER}
   65     delete>
   66     <insert id="insert" parameterType="com.wn.model.Flower">
   67         insert into t_flower (id,
   68         type, colour,
   69         number, price, florescence
   70         )
   71         values
   72         (#{id,jdbcType=INTEGER}, #{type,jdbcType=VARCHAR},
   73         #{colour,jdbcType=VARCHAR},
   74         #{number,jdbcType=INTEGER},
   75         #{price,jdbcType=DECIMAL}, #{florescence,jdbcType=INTEGER}
   76         )
   77     insert>
   78     <insert id="insertSelective" parameterType="com.wn.model.Flower">
   79         insert into t_flower
   80         <trim prefix="(" suffix=")" suffixOverrides=",">
   81             <if test="id != null">
   82                 id,
   83             if>
   84             <if test="type != null">
   85                 type,
   86             if>
   87             <if test="colour != null">
   88                 colour,
   89             if>
   90             <if test="number != null">
   91                 number,
   92             if>
   93             <if test="price != null">
   94                 price,
   95             if>
   96             <if test="florescence != null">
   97                 florescence,
   98             if>
   99         trim>
  100         <trim prefix="values (" suffix=")" suffixOverrides=",">
  101             <if test="id != null">
  102                 #{id,jdbcType=INTEGER},
  103             if>
  104             <if test="type != null">
  105                 #{type,jdbcType=VARCHAR},
  106             if>
  107             <if test="colour != null">
  108                 #{colour,jdbcType=VARCHAR},
  109             if>
  110             <if test="number != null">
  111                 #{number,jdbcType=INTEGER},
  112             if>
  113             <if test="price != null">
  114                 #{price,jdbcType=DECIMAL},
  115             if>
  116             <if test="florescence != null">
  117                 #{florescence,jdbcType=INTEGER},
  118             if>
  119         trim>
  120     insert>
  121     <update id="updateByPrimaryKeySelective" parameterType="com.wn.model.Flower">
  122         update t_flower
  123         <set>
  124             <if test="type != null">
  125                 type = #{type,jdbcType=VARCHAR},
  126             if>
  127             <if test="colour != null">
  128                 colour = #{colour,jdbcType=VARCHAR},
  129             if>
  130             <if test="number != null">
  131                 number = #{number,jdbcType=INTEGER},
  132             if>
  133             <if test="price != null">
  134                 price = #{price,jdbcType=DECIMAL},
  135             if>
  136             <if test="florescence != null">
  137                 florescence = #{florescence,jdbcType=INTEGER},
  138             if>
  139         set>
  140         where id = #{id,jdbcType=INTEGER}
  141     update>
  142     <update id="updateByPrimaryKey" parameterType="com.wn.model.Flower">
  143         update t_flower
  144         set type = #{type,jdbcType=VARCHAR},
  145         colour =
  146         #{colour,jdbcType=VARCHAR},
  147         number = #{number,jdbcType=INTEGER},
  148         price =
  149         #{price,jdbcType=DECIMAL},
  150         florescence =
  151         #{florescence,jdbcType=INTEGER}
  152         where id = #{id,jdbcType=INTEGER}
  153     update>
  154 mapper>

  View Code

• Flower
• 

   1 package com.wn.model;
   2 
   3 public class Flower {
   4     private Integer id;
   5 
   6     private String type;
   7 
   8     private String colour;
   9 
  10     private Integer number;
  11 
  12     private Long price;
  13 
  14     private Integer florescence;
  15 
  16     public Integer getId() {
  17         return id;
  18     }
  19 
  20     public void setId(Integer id) {
  21         this.id = id;
  22     }
  23 
  24     public String getType() {
  25         return type;
  26     }
  27 
  28     public void setType(String type) {
  29         this.type = type == null ? null : type.trim();
  30     }
  31 
  32     public String getColour() {
  33         return colour;
  34     }
  35 
  36     public void setColour(String colour) {
  37         this.colour = colour == null ? null : colour.trim();
  38     }
  39 
  40     public Integer getNumber() {
  41         return number;
  42     }
  43 
  44     public void setNumber(Integer number) {
  45         this.number = number;
  46     }
  47 
  48     public Long getPrice() {
  49         return price;
  50     }
  51 
  52     public void setPrice(Long price) {
  53         this.price = price;
  54     }
  55 
  56     public Integer getFlorescence() {
  57         return florescence;
  58     }
  59 
  60     public void setFlorescence(Integer florescence) {
  61         this.florescence = florescence;
  62     }
  63 }

  View Code

• FlowerMapper.java
• 

   1 package com.wn.mapper;
   2 
   3 import java.util.List;
   4 
   5 import org.apache.ibatis.annotations.Param;
   6 
   7 import com.wn.model.Flower;
   8 
   9 public interface FlowerMapper {
  10     int deleteByPrimaryKey(Integer id);
  11 
  12     int insert(Flower record);
  13 
  14     int insertSelective(Flower record);
  15 
  16     Flower selectByPrimaryKey(Integer id);
  17 
  18     List selectByCondition(Flower record);
  19     
  20     List selectLimit(@Param("start") int start, @Param("size") int size);
  21 
  22     int updateByPrimaryKeySelective(Flower record);
  23 
  24     int updateByPrimaryKey(Flower record);
  25     
  26     List selectByColour(String colour);
  27 }

  View Code

4、编写dao、service、controller

• FlowerDao
• 

   1 package com.wn.dao;
   2 
   3 import java.util.List;
   4 
   5 import org.springframework.beans.factory.annotation.Autowired;
   6 import org.springframework.stereotype.Repository;
   7 
   8 import com.wn.mapper.FlowerMapper;
   9 import com.wn.model.Flower;
  10 
  11 @Repository
  12 public class FlowerDao {
  13     @Autowired
  14     private FlowerMapper flowerMapper;
  15 
  16     public boolean add(Flower flower) {
  17         return flowerMapper.insert(flower) == 1 ? true : false;
  18     }
  19 
  20     public Flower getById(Integer id) {
  21         return flowerMapper.selectByPrimaryKey(id);
  22     }
  23 
  24     public boolean deleteById(Integer id) {
  25         return flowerMapper.deleteByPrimaryKey(id) == 1 ? true : false;
  26     }
  27 
  28     public boolean update(Flower flower) {
  29         return flowerMapper.updateByPrimaryKey(flower) == 1 ? true : false;
  30     }
  31 
  32     public boolean update2(Flower flower) {
  33         return flowerMapper.updateByPrimaryKeySelective(flower) == 1 ? true : false;
  34     }
  35 
  36     /*
  37      * 实现条件不定查询
  38      */
  39     public List getByCondition(Flower flower) {
  40         return flowerMapper.selectByCondition(flower);
  41     }
  42 
  43     /*
  44      * 传入开始显示记录的索引，即显示记录的条数，实现分页显示功能
  45      */
  46     public List selectLimit(int start, int size) {
  47         return flowerMapper.selectLimit(start, size);
  48     }
  49 
  50     public List selectByColour(String colour) {
  51         return flowerMapper.selectByColour(colour);
  52     }
  53 }

  View Code
• FlowerService
• 

   1 package com.wn.service;
   2 
   3 import java.util.List;
   4 import java.util.concurrent.ExecutionException;
   5 import java.util.concurrent.TimeUnit;
   6 
   7 import org.springframework.beans.factory.annotation.Autowired;
   8 import org.springframework.stereotype.Service;
   9 
  10 import com.google.common.cache.CacheBuilder;
  11 import com.google.common.cache.CacheLoader;
  12 import com.google.common.cache.LoadingCache;
  13 import com.wn.dao.FlowerDao;
  14 import com.wn.model.Flower;
  15 
  16 @Service
  17 public class FlowerService {
  18     @Autowired
  19     private FlowerDao flowerDao;
  20 
  21     public boolean addFlower(String type, String colour, Integer number, long price, Integer florescence) {
  22         Flower flower = new Flower();
  23         flower.setType(type);
  24         flower.setColour(colour);
  25         flower.setNumber(number);
  26         flower.setPrice(price);
  27         flower.setFlorescence(florescence);
  28         return flowerDao.add(flower);
  29     }
  30 
  31     public Flower getFlower(Integer id) {
  32         return flowerDao.getById(id);
  33     }
  34 
  35     public boolean deleteFlower(Integer id) {
  36         return flowerDao.deleteById(id);
  37     }
  38 
  39     public boolean updateFlower(Integer id, String type, String colour, Integer number, Long price,
  40             Integer florescence) {
  41         Flower flower = flowerDao.getById(id);
  42         flower.setType(type);
  43         flower.setColour(colour);
  44         flower.setNumber(number);
  45         flower.setPrice(price);
  46         flower.setFlorescence(florescence);
  47         return flowerDao.update(flower);
  48     }
  49 
  50     public boolean updateFlower2(Integer id, String type, String colour, Integer number, Long price,
  51             Integer florescence) {
  52         Flower flower = flowerDao.getById(id);
  53         flower.setType(type);
  54         flower.setColour(colour);
  55         flower.setNumber(number);
  56         flower.setPrice(price);
  57         flower.setFlorescence(florescence);
  58         return flowerDao.update2(flower);
  59     }
  60 
  61     public List getFlowerByCondition(String type, String colour, Integer number, Long price,
  62             Integer florescence) {
  63         Flower flower = new Flower();
  64         flower.setColour(colour);
  65         flower.setType(type);
  66         flower.setNumber(number);
  67         flower.setPrice(price);
  68         flower.setFlorescence(florescence);
  69         return flowerDao.getByCondition(flower);
  70     }
  71 
  72     public List selectLimit(Integer start, Integer size) {
  73         return flowerDao.selectLimit(start, size);
  74     }
  75 
  76     /**本地缓存-guava cache的流程：
  77      * 1、从guava cache中获取 -- flowerCache.get(colour) 
  78      * 2、如果存在，直接返回数据给controller
  79      * 3、如果不存在，调用load方法（先从mysql获取，再存入guava cache，最后从guava
  80      * cache读出该数据，返回给controller）
  81      */
  82     public List getFlowerWithCache(String colour) {
  83         List flowerList = null;
  84         try {
  85             flowerList = flowerCache.get(colour);
  86         } catch (ExecutionException e) {
  87             e.printStackTrace();
  88         }
  89         return flowerList;
  90     }
  91     LoadingCache> flowerCache = CacheBuilder.newBuilder().expireAfterWrite(2, TimeUnit.MINUTES)
  92             .maximumSize(200).build(new CacheLoader>() {
  93                 public List load(String colour) {
  94                     System.out.println("从数据库查");
  95                     return flowerDao.selectByColour(colour);
  96                 }
  97             });
  98 }

  View Code  
• FlowerController
• 

   1 package com.wn.controller;
   2 
   3 import java.util.List;
   4 
   5 import org.springframework.beans.factory.annotation.Autowired;
   6 import org.springframework.web.bind.annotation.PathVariable;
   7 import org.springframework.web.bind.annotation.RequestMapping;
   8 import org.springframework.web.bind.annotation.RequestMethod;
   9 import org.springframework.web.bind.annotation.RequestParam;
  10 import org.springframework.web.bind.annotation.RestController;
  11 
  12 import com.wn.model.Flower;
  13 import com.wn.service.FlowerService;
  14 
  15 @RestController
  16 @RequestMapping("/flower")
  17 public class FlowerController {
  18     @Autowired
  19     private FlowerService flowerService;
  20 
  21     @RequestMapping(value = "/add", method = RequestMethod.POST)
  22     public boolean addFlower(@RequestParam("type") String type, @RequestParam("colour") String colour,
  23             @RequestParam("number") Integer number, @RequestParam("price") Long price,
  24             @RequestParam("florescence") Integer florescence) {
  25         return flowerService.addFlower(type, colour, number, price, florescence);
  26     }
  27 
  28     @RequestMapping(value = "/get", method = RequestMethod.GET)
  29     public Flower getFlower(Integer id) {
  30         return flowerService.getFlower(id);
  31     }
  32 
  33     @RequestMapping(value = "/delete/{id}", method = RequestMethod.DELETE)
  34     public boolean deleteFlower(@PathVariable("id") Integer id) {
  35         return flowerService.deleteFlower(id);
  36     }
  37 
  38     @RequestMapping(value = "/update", method = RequestMethod.PUT)
  39     public boolean updateFlower(@RequestParam(value = "id") Integer id,
  40             @RequestParam(value = "type", required = false) String type,
  41             @RequestParam(value = "colour", required = false) String colour,
  42             @RequestParam(value = "number", required = false) Integer number,
  43             @RequestParam(value = "price", required = false) Long price,
  44             @RequestParam(value = "florescence", required = false) Integer florescence) {
  45 
  46         return flowerService.updateFlower(id, type, colour, number, price, florescence);
  47     }
  48 
  49     @RequestMapping(value = "/update2", method = RequestMethod.PUT)
  50     public boolean updateFlower2(@RequestParam(value = "id") Integer id,
  51             @RequestParam(value = "type", required = false) String type,
  52             @RequestParam(value = "colour", required = false) String colour,
  53             @RequestParam(value = "number", required = false) Integer number, @RequestParam(value = "price") Long price,
  54             @RequestParam(value = "florescence", required = false) Integer florescence) {
  55         return flowerService.updateFlower2(id, type, colour, number, price, florescence);
  56     }
  57 
  58     @RequestMapping(value = "/getFlowerByConditon", method = RequestMethod.GET)
  59     public List getFlowerByCondition(@RequestParam(value = "type", required = false) String type,
  60             @RequestParam(value = "colour", required = false) String colour,
  61             @RequestParam(value = "number", required = false) Integer number,
  62             @RequestParam(value = "price", required = false) Long price,
  63             @RequestParam(value = "florescence", required = false) Integer florescence) {
  64         return flowerService.getFlowerByCondition(type, colour, number, price, florescence);
  65     }
  66 
  67     @RequestMapping(value = "/getFlowerByLimit", method = RequestMethod.GET)
  68     public List getFlowerByLimit(@RequestParam("start") Integer start, @RequestParam("size") Integer size) {
  69         return flowerService.selectLimit(start, size);
  70     }
  71 
  72     // 从本地缓存获取数据，若本地缓存没有，再从数据库获取
  73     @RequestMapping(value = "/getWithCache", method = RequestMethod.GET)
  74     public List getWithCache(@RequestParam("colour") String colour) {
  75         return flowerService.getFlowerWithCache(colour);
  76     }
  77 }

  View Code

   

转载于:https://www.cnblogs.com/wangna----558169/p/6081683.html