在电影的拍摄中多久算做是长镜头
更新时间：2015-12-31本文内容转载自互联网
什么是影视中的长镜头
长镜头是指连续地用一个镜头拍摄下一个场景，一场戏或一段戏，以完成一个比较完整的镜头段落，而不破坏事件发展中时间和空间连贯性的镜头。
一般认为，电影史上最早应用长镜头的范例是“纪录片之父”罗伯特・弗拉哈迪1916年拍摄的纪录片《北方的纳努克》。
1941年美国奥逊・威尔斯在他的经典影片《公民凯恩》中，又成功地运用了长镜头段落和景深镜头、运动摄影以及多视角的叙事结构。这部影片被誉为“现代电影的里程碑”。
长镜头是指连续地对一个场景、一场戏进行较长时间的拍摄，所形成的镜头。
在拍摄长镜头时，通过摄象机的运动，形成多角度、多机位的效果，造成画面
空间的真实感和一气呵成的整体感。
它原为电影的拍摄技巧，产生于上世纪20年代。在电影发明之初，剪辑技巧还没
成为专门的制作手段时，电影画面大多是采用长镜头拍摄的。
长镜头最根本的在于镜头内纵深的场面调度产生的纪实性和整个影片节奏的起承转合所体现的现实主义风格。当然，相对而言，讲求景深内的场面调度会使镜头的时间变长、节奏变慢。看看侯孝贤等台湾导演的电影就相当明显。
大景深长镜头：是一种采用深焦距拍摄的长镜头。是在长镜头内实现现场画面调度的手段。
这种镜头常用来保持画面时间和空间上的完整统一。
其作用为：
a.能以一个单独的镜头表现完整的动作和事件，而其含义不依赖它与前后镜头的联结就能独立存在
b.强调长镜头在时间上的连续性和深焦距造成的完整的空间的作用，形成几个平面互相衬映、互相
对比的复杂画面空间结构
c.由于这种多层面和多元性的画面，比然派生出多义性，使大家在欣赏影片时有相当大的选择自由
并自由地对画面形象的某些或全部含义做出自己的判断和理解。
摄影长镜头的缺点
首先，质量上乘的长镜头价格昂贵.
其次，长镜头往往又大又笨重，在你整天背着它到处转之后，就会有切身体会.
第三，镜头的焦距越长，照相机就必须把握得越稳定，以避免影像模糊.经验准则是只有当快门速度至少等于镜头焦距毫米数的倒数时才能够手持镜头进行拍摄.也就是说，当快门速度低于1/100秒时就不能手持100mm镜头拍摄，低于1/1500秒时就不能手持500mm镜头拍摄等等.在下一课中还会讲到.为了确保得到锐利的影像，我们推荐设置更高的快门速度.我们推荐的设置值是镜头焦距的"两倍".也就是说，当快门速度低于1/200秒时就不能手持100mm镜头拍摄，低于1/1000秒时就不能手持500mm镜头拍摄.因此，对于大多数远摄镜头的拍摄工作都需用要使用三脚架.这样，你不仅仅要背着那只长镜头，而且还要扛着三脚架.
第四，不管长镜头的光学系统多么完美，拍摄远处的物体时，影像总是处于充满尘埃、阴霾和热折射的大气环境中。只有在非常罕见的清澈空气中，才能获得特别清晰的远摄影像。
我们建议在练习的这个阶段，除了照相机上已经配备的镜头之外，不必再购买任何镜头。以后成为"高手"时，可以考虑较长焦距的镜头。即使在那时，除非对超长镜头具有特殊的需求，并且资金也不成问题，否则我们建议不要考虑超过200mm的任何镜头。如果偶尔需要超长镜头，可以考虑添置一只远摄增距镜。
有用 86
无用 27
我要提问

因为各种各样的事情，刷题耽搁了一段时间。现在新冠肺炎疫情严重，还不能回学校，正好趁着机会把剩下的题都刷完吧！同时也希望疫情早日结束！
41.小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!
利用双指针：当总和小于sum，大指针继续+，否则小指针+

话说双指针真的是一个非常常用而又牛逼的方法呀！
class Solution {
public:
    vector<vector<int> > FindContinuousSequence(int sum) {
         vector<vector<int> > result;
        int phigh = 2,plow = 1;
        
        while(phigh > plow){//初中数学：等差数列求和公式是(a0+an)*n/2
            int cur = (phigh + plow) * (phigh - plow + 1) / 2;

            if( cur == sum){//相等，那么就将窗口范围的所有数添加进结果集
                vector<int> res;
                for(int i = plow; i<=phigh; i++)
                    res.push_back(i);
                result.push_back(res);
                plow++;
            }

            if( cur < sum)//如果当前窗口内的值之和小于sum，那么右边窗口右移一下
                phigh++;          
             
            if(cur > sum)//如果当前窗口内的值之和大于sum，那么左边窗口右移一下
                plow++;
        }         
        return result;
    }
};

42.输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
因为是有序的，所以思路依旧和上一题类似，依然用双指针的做法：

数列满足递增，设两个头尾两个指针i和j，

若ai + aj == sum，就是答案（相差越远乘积越小）

若ai + aj > sum，aj肯定不是答案之一（前面已得出 i 前面的数已是不可能），j -= 1

若ai + aj < sum，ai肯定不是答案之一（前面已得出 j 后面的数已是不可能），i += 1
class Solution {
public:
    vector<int> FindNumbersWithSum(vector<int> array,int sum) {
        vector<int> result;
        int n = array.size();
        if (n <= 1)
            return result;

        int i = 0;
        int j = n - 1;

        while (i < j) {
            if (array[i] + array[j] > sum)
                j--;
            else if (array[i] + array[j] < sum)
                i++;
            else {
                result.push_back(array[i]);
                result.push_back(array[j]);
                break;
            }
        }
        return result;
    }
};

43.汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！
思路：参考剑指书上的思路。这道题考查的核心是灵活利用字符串翻转。假设字符串abcdef，n=3，设X=abc，Y=def，所以字符串可以表示成XY，如题干，问如何求得YX。假设X的翻转为XT，XT=cba，同理YT=fed，那么YX=(XTYT)T，l利用最基本的翻转字符串，三次翻转后可得结果。
class Solution {
public:
    string LeftRotateString(string &str, int n)
    {
        int length = str.size();
        if(!str.empty() && n <= length)
        {
            if(n >= 0 && n <= length)
            {
                int pFirstStart = 0;
                int pFirstEnd = n - 1;
                int pSecondStart = n;
                int pSecondEnd = length - 1; 
                
                reverse(str, pFirstStart, pFirstEnd);// 翻转字符串的前面n个字符                
                reverse(str, pSecondStart, pSecondEnd);// 翻转字符串的后面部分                
                reverse(str, pFirstStart, pSecondEnd);// 翻转整个字符串
            }
        }
        return str; 
    }

    void reverse(string &str, int begin, int end)
    {
        while(begin < end)
        {
            char tmp = str[begin];
            str[begin] = str[end];
            str[end] = tmp;
            begin++;
            end--;
        }
    }
};

44.牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？
最直接最一目了然的解法：
class Solution {
public:
    string ReverseSentence(string str) {
        ReverseWord(str, 0, str.size() - 1); //先整体翻转
        int s = 0, e = 0;
        int i = 0;
        while(i < str.size()) {
            while(i < str.size() && str[i] == ' '){ //空格跳过
                i++;
            }
            e = s = i; //记录单词的第一个字符的位置
            while(i < str.size() && str[i] != ' ') {//不是空格 找单词最后一个字符的位置
                i++;
                e++;
            }
            ReverseWord(str, s, e - 1); //局部翻转
        }
        return str;
        }
    
        //翻转str从s到e的部分
        void ReverseWord(string &str, int s, int e) {
            while(s < e)
                swap(str[s++], str[e--]);
        }    
};

45.LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。
这题的描述也是很有OJ内味儿了啊（逃

具体的思路是：满足顺子要有两个条件：

除0外没有重复的数
max - min < 5

class Solution {
public:
    bool IsContinuous( vector<int> numbers ) {
        if(numbers.empty())
            return 0;
        int count[14]={0};//记录每个元素出现的次数;以numbers中的元素作为下标(最大K,对应13)
        int length=numbers.size();
        int max=-1;
        int min=14;

        for(int i=0;i<length;++i) {
            count[numbers[i]]++;

            if(numbers[i]==0) 
                continue;

            if(count[numbers[i]]>1) 
                return 0;

            if(numbers[i]>max) 
                max=numbers[i];

            if(numbers[i]<min) 
                min=numbers[i];
        }

        if(max-min<5)
            return 1;
        else
            return 0;
    }
};

46.每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1) 如果没有小朋友，请返回-1
大佬的思路解析：如果只求最后一个报数胜利者的话，我们可以用数学归纳法解决该问题，为了讨      论方便，先把问题稍微改变一下，并不影响原意：

问题描述：n个人（编号0~(n-1))，从0开始报数，报到(m-1)的退出，剩下的人 继续从0开始报数。求胜利者的编号。

我们知道第一个人(编号一定是m%n-1) 出列之后，剩下的n-1个人组成了一个新      的约瑟夫环（以编号为k=m%n的人开始）:
    k  k+1  k+2  ... n-2, n-1, 0, 1, 2, ... k-2并且从k开始报0。

现在我们把他们的编号做一下转换：

k     --> 0

k+1   --> 1

k+2   --> 2

…

…

k-2   --> n-2

k-1   --> n-1

变换后就完完全全成为了(n-1)个人报数的子问题，假如我们知道这个子问题的解： 例如x是最终的胜利者，那么根据上面这个表把这个x变回去不刚好就是n个人情 况的解吗？！！变回去的公式很简单，相信大家都可以推出来：x’=(x+k)%n。
令f[i]表示i个人玩游戏报m退出最后胜利者的编号，最后的结果自然是f[n]。
递推公式

f[1]=0;

f[i]=(f[i-1]+m)%i;  (i>1)
有了这个公式，我们要做的就是从1-n顺序算出f[i]的数值，最后结果是f[n]。 因为实际生活中编号总是从1开始，我们输出f[n]+1。

具体代码：
class Solution {
public:
    int LastRemaining_Solution(int n, int m)
    {
        if(n==0)
            return -1;
        if(n==1)
            return 0;
        else
            return (LastRemaining_Solution(n-1,m)+m)%n;
    }
};

47.求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
解题思路：

1.需利用逻辑与的短路特性实现递归终止。

2.当n==0时，(n>0)&&((sum+=Sum_Solution(n-1))>0)只执行前面的判断，为false，然后直接返回0；

3.当n>0时，执行sum+=Sum_Solution(n-1)，实现递归计算Sum_Solution(n)。
class Solution {
public:
    int Sum_Solution(int n) {
        int answer = n;
        answer && (answer += Sum_Solution(n - 1));
        return answer;
    }
};

48.写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。
不用传统的计算方法，那当然就是想到用位运算啦！

首先看十进制是如何做的： 5+7=12，三步走

第一步：相加各位的值，不算进位，得到2。

第二步：计算进位值，得到10. 如果这一步的进位值为0，那么第一步得到的值就是最终结果。

第三步：重复上述两步，只是相加的值变成上述两步的得到的结果2和10，得到12。
同样我们可以用三步走的方式计算二进制值相加： 5-101，7-111

第一步：相加各位的值，不算进位，得到010，二进制每位相加就相当于各位做异或操作，101^111。

第二步：计算进位值，得到1010，相当于各位做与操作得到101，再向左移一位得到1010，(101&111)<<1。

第三步重复上述两步， 各位相加 010^1010=1000，进位值为100=(010&1010)<<1。

继续重复上述两步：1000^100 = 1100，进位值为0，跳出循环，1100为最终结果。
class Solution {
public:
    int Add(int num1, int num2)
    {
        while (num2!=0) {
            int temp = num1^num2;
            num2 = (num1&num2)<<1;
            num1 = temp;
        }
        return num1;
    }
};

话说，看到一个汇编指令的解法，也是真的秀哈哈哈哈哈哈~
int add(int a, int b)
{
    _asm
    {
        MOV EAX, a
        MOV ECX, b
        ADD EAX, ECX
    }
}

49.将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0
要注意这题的坑点–边界条件：

数据上下 溢出
空字符串
只有正负号
有无正负号
错误标志输出

class Solution {
public:
    int StrToInt(string str) {
        int length = str.length(), result = 0, i =0;
        bool flag = false;

        while(i<length&&str[i]==' ')//剔除空格
            i++;

        if(i < length&&(str[i]=='+'||str[i]=='-')) {
            if(str[i]=='-')
                flag = true;
            i++;
        }
        
        while(i<length&&str[i]>='0'&&str[i]<='9') {
            //判断是否溢出，这是最令人头疼的
            if(!flag&&(result>INT_MAX/10||((result==INT_MAX/10)&&INT_MAX%10<(str[i]-'0')))) {
                result = 0;
                break;
            }
            else if(flag&&(result<INT_MIN/10||((result==INT_MIN/10)&&INT_MIN%10>('0'-str[i])))) {
                result = 0;
                break;
            }
            else {
                if(!flag)
                 result = result*10+(str[i]-'0');
                else
                 result = result*10-(str[i]-'0');//需要注意的是这里一定更要对str[i]进行减'0’的操作！！！
                i++; 
            }
        }
        
        if(i<length)//空字符串
            return 0;
        return result;
    }
};

50.在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组{2,3,1,0,2,5,3}，那么对应的输出是第一个重复的数字2。
class Solution {
public:
    // Parameters:
    //        numbers:     an array of integers
    //        length:      the length of array numbers
    //        duplication: (Output) the duplicated number in the array number
    // Return value:       true if the input is valid, and there are some duplications in the array number
    //                     otherwise false
    bool duplicate(int numbers[], int length, int* duplication) {
        for(int i=0;i!=length;++i) {
            int index=numbers[i]%length;
            
            if(numbers[index]>=length) {
                *duplication=index;
                return 1;
            }
            numbers[index]+=length;
        }
        return 0;
    }
};

深圳请月嫂请多久比较好？按照行规月嫂一个月实际是服务26天。但是产后恢复是按6周计算，因为子宫恢复期是42天，所以呢，一般条件允许的情况下，请月嫂照顾月子最好是42天。
产褥期（即民间所说的“坐月子”）是指产后6~8周。产褥期对产妇来说非常重要，在这段时间里，产妇的乳房要泌乳，子宫要复原，身体的各个系统要逐渐恢复正常。体形、腹壁等，也在逐渐复原。
如果产褥期没有恢复好，将会是影响一辈子的事情。
发现了吗？是6-8周，而不是正好一个月。
如果产妇身体虚弱，恢复时间又要延长，时间久一点，是万无一失的选择。
具体分析：
1、有很多人为了能够恢复的更好请两个月的月嫂，也就是52天。头6周老老实实坐好月子就行，基本上什么都不用操心，除了喂奶啥事不干，后几天跟着月嫂再学习一下洗澡、抚触等照顾宝宝的技能，做好最后的交接工作。
2、月嫂的工作时间分为两种情况，一种是白班月嫂，只负责白天对宝宝和产妇的照顾。另一种是住家月嫂，专门为宝宝和产妇提供24小时服务的。
住家月嫂24小时住家 ，对产后妈妈进行照顾，不用产后妈妈们费心去照顾宝宝。避免了产后妈妈们需要起夜照顾宝宝的麻烦，能够得到充足的睡眠。
也有很多人坐月子是由家里老人照顾的，可能会有带孩子的经验，但对于孩子的肚脐护理、新生儿疾病观察、产妇恶露情况观察等专业方面不是很了解，所以造成了婆婆/妈妈只顾着照顾孩子，冷落了产妇的现象。
这就是为什么现在很多产妇在产后出现了抑郁症的情况。
如果有经验丰富、专业技能过关的月嫂负责护理新生儿和产妇，可以保证这个月子做的科学、舒适，还能有效的缓解产妇与家庭新老观念碰撞所产生的矛盾。
还能为产妇做心理疏导交流育儿心得，让产后妈妈更快的去适应新角色的转换，防止产后抑郁的出现。
如果您请了月嫂照顾，各方面都还比较满意的月嫂，您可以多签月嫂一个月，让她能照顾您42天的产褥期。
享母婴健康，找多喜娃。
多喜娃致力于为妈妈们提供最标准最专业的母婴护理服务，迄今为止，累计服务客户超过10万名，客户满意度达到95%以上。多喜娃月子服务，提供的不仅是针对月嫂的个人服务，而是针对月子期的由月嫂、营养师、催乳师、月嫂培训老师、专属客服、月嫂日记管理老师共同组成的团队服务，帮助妈妈恢复好、宝宝发育好。
如果是金牌月嫂、口碑高技能好，你想续签需要提前告知月嫂，因为现在好月嫂可是供不应求的！

一、简介
缓存工作的原则，就是“引用的局部性”，这可以分为时间局部性和空间局部性。空间局部性是指CPU在某一时刻需要某个数据，那么很可能下一步就需要其附近的数据；时间局部性是指当某个数据被访问过一次之后，过不了多久时间就会被再一次访问。
常用缓存算法：
1.LRU算法

LRU（The Least Recently Used，最近最久未使用算法）是一种常见的缓存算法，如果一个数据在最近一段时间没有被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最久没有访问的数据最先被置换（淘汰）。
2.LFU算法

LFU（Least Frequently Used ，最近最少使用算法）也是一种常见的缓存算法。

如果一个数据在最近一段时间很少被访问到，那么可以认为在将来它被访问的可能性也很小。因此，当空间满时，最小频率访问的数据最先被淘汰。
3.FIFO算法

FIFO 算法是一种比较容易实现的算法。思想是先进先出（FIFO，队列），这是最简单、最公平的一种思想，即如果一个数据是最先进入的，那么可以认为在将来它被访问的可能性很小。空间满的时候，最先进入的数据会被最早置换（淘汰）掉。
二、Ehcache
Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存,Java EE和轻量级容器。
Ehcache 直接在jvm虚拟机中缓存，速度快，效率高；缓存数据有两级：内存和磁盘，因此无需担心容量问题但是缓存共享麻烦，集群分布式应用不方便。处理集群和分布式缓存方便，有成熟的方案。如果是单个应用或者对缓存访问要求很高的应用，用ehcache。如果是大型系统，存在缓存共享、分布式部署、缓存内容很大的，建议用redis。
三、流程
spring 已将缓存领域统一，无论使用哪种缓存实现，不同的只是缓存配置，开发者使用的缓存注解都是一致的。
spring boot 可以非常方便使用ehcache,如果ehcache 依赖存在，并且classpath 下有一个ehcache.xml 配置，EhCacheManager 将自动作为缓存实现。
1.新建spring boot 项目，pom.xml 添加依赖
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<dependency>
	<groupId>net.sf.ehcache</groupId>
	<artifactId>ehcache</artifactId>
</dependency>

2.resources 下新建ehcache.xml
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd">
 
  <!-- 磁盘缓存位置 -->
  <diskStore path="./ehcache"/>
 
  <!-- 默认缓存 -->
  <defaultCache
          maxEntriesLocalHeap="100"
          eternal="false"
          timeToIdleSeconds="120"
          timeToLiveSeconds="120"
          diskExpiryThreadIntervalSeconds="120">
          
  </defaultCache>
  
  <!-- 配置一个default_cache  的缓存 -->
  <cache name="default_cache" 
   		  maxEntriesLocalHeap="100"
          eternal="false"
          timeToIdleSeconds="120"
          timeToLiveSeconds="120"
          diskExpiryThreadIntervalSeconds="120">
  </cache>
  
         
</ehcache>

3.@SpringBootApplication 修饰的启动类添加 @EnableCaching 注解开启缓存配置
4.User.java
package com.vincent.po;

import java.io.Serializable;

public class User implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private String name;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [name=" + name + ", age=" + age + "]";
	}

}

5.UserService.java
package com.vincent.service;

import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.vincent.po.User;

@Service
public class UserService {
	@Cacheable(cacheNames = {"default_cache"},key = "#id")
	public User get(String id) {
		User user = new User();
		user.setName("Vincent");
		user.setAge(26);
		System.out.println("cache method...");
		return user;
	}
	
	@CachePut(cacheNames = {"default_cache"},key = "#id")
	public User update(String id){
		
		User user = new User();
		user.setName("Vincent-" + id);
		user.setAge(26);
		System.out.println("update method...");
		return user;
	}
	
	@CacheEvict(cacheNames = {"default_cache"},key = "#id")
	public void delete(String id) {
		System.out.println("delete method...");
	}
}

@Cacheable 表示对方法进行缓存，默认情况下缓存的key 是方法的参数，缓存的value 是方法的返回值，其他类中调用该方法时，首先会根据调用参数查看缓存中是否有相关数据，如有则直接使用缓存数据，该方法不会执行，否则执行该方法并把返回值缓存起来
@CachePut 用于数据更新方法上，每次执行时都不会检查是否已有数据，而是直接执行方法，让后将执行结果缓存起来，如果该key对应的数据已经存在将会被覆盖
@CacheEvice 表示移除一个key 对应的缓存
6.TestController.java
package com.vincent.controller;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import com.vincent.po.User;
import com.vincent.service.UserService;

@RestController
public class TestController {
	
	@Autowired 
	private UserService userService;
	
	@GetMapping("/test/add")
	public User add(String id) {
		return userService.get(id);
	}
	
	@GetMapping("/test/update")
	public User update(String id) {
		return userService.update(id);
	}

	
	@GetMapping("/test/del")
	public void del(String id) {
		userService.delete(id);
	}
	
}

四、测试
1.访问 http://localhost:8080/test/add?id=test-cache
浏览器输出：


控制台输出：



多次刷新该接口控制台输出没有多余的 cache method… ，表面数据缓存成功
2.访问  http://localhost:8080/test/update?id=test-cache 更新数据


控制台输出如下：


再次刷新该接口控制台将再次执行该更新方法

3.访问 http://localhost:8080/test/del?id=test-cache
浏览器没有任何信息


控制台输出   delete method…
4.再次访问  http://localhost:8080/test/add?id=test-cache  缓存方法将被执行。

控制台输出 cache method…
五、总结
ehcache.xml 配置文件中需要配置缓存名字如：
<cache name="xxx" />

代码中对缓存的注解中需要指定 cacheNames 缓存名称，否制会抛异常，



查找相关异常代码如下



在使用ehcache 时需要指定缓存名字，否制会抛异常。ehcache.xml 配置中的defaultCache 就没什么作用，cache 配置的参数和 defaultCache 一样，不过多了一个name 属性。defaultCache 可能时给用户参考配置使用的。
cache 配置参数说明如下：
name : 缓存的名称，可以通过指定名称获取指定的某个Cache对象
maxElementsInMemory ：内存中允许存储的最大的元素个数，0代表无限个
clearOnFlush：内存数量最大时是否清除。
eternal ：设置缓存中对象是否为永久的，如果是，超时设置将被忽略，对象从不过期。根据存储数据的不同，例如一些静态不变的数据如省市区等可以设置为永不过时
timeToIdleSeconds ： 设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds ：缓存数据的生存时间（TTL），也就是一个元素从构建到消亡的最大时间间隔值，这只能在元素不是永久驻留时有效，如果该值是0就意味着元素可以停顿无穷长的时间。
overflowToDisk ：内存不足时，是否启用磁盘缓存。
maxEntriesLocalDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
maxElementsOnDisk：硬盘最大缓存个数。
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
diskPersistent：是否在VM重启时存储硬盘的缓存数据。默认值是false。
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
maxEntriesLocalHeap：是用来限制当前缓存在堆内存上所能保存的最大元素数量的。Ehcache规定如果在CacheManager上没有指定maxBytesLocalHeap时必须在各个Cache上指定maxBytesLocalHeap或者maxEntriesLocalHeap，但maxEntriesLocalHeap和maxBytesLocalHeap不能同时出现。也就是说我们不能在一个Cache上同时指定maxBytesLocalHeap和maxEntriesLocalHeap，也不能在Cache上指定maxEntriesLocalHeap的同时在CacheManager上指定maxBytesLocalHeap。但同时在CacheManager和Cache上指定maxBytesLocalHeap则是允许的。