修改了前期的缓存代码

用try/catch的原因是 

获取缓存代码

如果这个缓存代码没有结果 

rs是int类型的   没法用if  判断空值， 判断数字大小又不符合业务

所以用try/catch，倒是能运行，但很奇怪。

后面想到还有包装类Integer这个东西

就修改成下面这样， 这样就能判断返回int类型缓存值是否为空了

@Override
public int MemCountStudent() {
   
   Integer rs = (Integer) client.get("MemCountStudent");
   
   if (rs!=null){
       logger.info("有缓存，缓存为" + rs + "现在开始返回缓存");
       return rs;

   }else{
       //如果缓存为空   返回缓存数据
       logger.info("没有缓存,现在从数据库查询数据");
       int rss = studentMapper.countStudent();
       logger.info("从数据库中查询处的数据为" + rss);

       try {
           logger.info("现在开始把数据放入缓存");
           boolean state = client.set("MemCountStudent", rss);
           logger.info("添加新缓存是否成功" + state);
           return rss;
       }catch (Exception e){
           logger.info(e.toString());
           return rss;
       }
   }

完成Spring+redis的代码整合

redis.properties  文件

#最大能够保持idel状态的对象数
redis.maxIdle=800
redis.minIdle=100

#当池内没有返回对象时，最大等待时间
redis.maxWaitMillis=3000

#最大活动对象数
redis.maxTotal=128
redis.host=127.0.0.1
redis.port=6379

#客户端超时时间
redis.timeout=0
#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个
redis.testOnBorrow=true  
#在空闲时检查有效性, 默认false
redis.testWhileIdle=true  
#是否进行有效性检查
redis.testOnReturn=true
       
#没密码就注释掉
#redis.password=123456

spring+redis文件

<?xml version="1.0" encoding="UTF-8"?>
<beans    xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:component-scan base-package="com"/>
   <context:property-placeholder location="classpath:redis.properties" ignore-unresolvable="true"/>
   <!--设置数据池-->
   <bean id="poolConfig"  class="redis.clients.jedis.JedisPoolConfig">
       <property name="maxIdle" value="${redis.maxIdle}"></property>
       <property name="minIdle" value="${redis.minIdle}"></property>
       <property name="maxTotal" value="${redis.maxTotal}"></property>
       <property name="maxWaitMillis" value="${redis.maxWaitMillis}"></property>
       <property name="testOnBorrow" value="${redis.testOnBorrow}"></property>
   </bean>
   <!--链接redis-->
   <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
       <property name="hostName" value="${redis.host}"></property>
       <property name="port" value="${redis.port}"></property>
<!--        <property name="password" value="${redis.password}"></property>-->
       <property name="poolConfig" ref="poolConfig"></property>
   </bean>

   <!-- redis 序列化策略 ，手动指定 key 采用String序列化策略 -->
   <bean id="stringSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer"/>

   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate" >
       <property name="connectionFactory" ref="connectionFactory"/>
       <property name="keySerializer" ref="stringSerializer"/>
       <!-- 开启事务，可以通过transcational注解控制 -->
       <property name="enableTransactionSupport" value="true"/>
   </bean>

</beans>

applicationContext.xml  引入spring+redis文件

<!--    引入redis.xml文件-->
<import resource="classpath:spring-redis.xml" />

实现类中的代码

@Override
public int RedisCountStudent() {

   Integer rs =(Integer) redisTemplate.opsForValue().get("RedisCountStudent");

   if(rs!= null){

       logger.info("有缓存，缓存为" + rs + "现在开始返回缓存");
       return rs;

   }else{

       //如果缓存为空   返回缓存数据
       logger.info("没有缓存,现在从数据库查询数据");
       int rss = studentMapper.countStudent();

       logger.info("从数据库中查询处的数据为" + rss);

       try {
           logger.info("现在开始把数据放入缓存");
           redisTemplate.opsForValue().set("RedisCountStudent",rss);
           logger.info("放入缓存成功");
       }catch (Exception e){
           logger.info(e.toString());
           logger.info("放入缓存失败！");
       }
       return rss;
   }
   }

List<student> student = (List<student>)redisTemplate.opsForValue().get("RedisStudent");
   logger.info("查询出的缓存值为" + student);

   if (student != null && student.size()>0) {
       logger.info("返回缓存");
       return student;

   } else {

       logger.info("缓存为空，现在从数据库查询数据");
       List<student> students = studentMapper.allStudent();
       logger.info("从数据库中查询处的数据为" + students);

       try {
           logger.info("把数据放入缓存");
           redisTemplate.opsForValue().set("RedisStudent",students);
           logger.info("添加缓存成功");
       }catch (Exception e){
           logger.info(e.toString());
           logger.info("放入缓存失败！");
       }
       return students;
   }
}

把首页的jsp页面的所有数据都加上了缓存

//带缓存
@RequestMapping(value = "/MemhomePage", method = RequestMethod.GET)
public String MemallStudent(Model model) {

   try {
       List<student> students = studentService.MemAllStudent();
       List<company> company = companyService.MemAllCompany();
       int countStudent = studentService.MemCountStudent();
       int countCompany = companyService.MemCountCompany();
       int countSatisfiedSalary = studentService.MemCountSatisfiedSalary();

       model.addAttribute("students", students);
       model.addAttribute("company", company);
       model.addAttribute("countStudent", countStudent);
       model.addAttribute("countCompany", countCompany);
       model.addAttribute("countSatisfiedSalary", countSatisfiedSalary);
       return "homePage";

   } catch (Exception e) {
       return "index";
   }
}

5个方法

companyServiceImpl  俩

@Override
public List<company> MemAllCompany(){

   //取出所有学生的缓存
   List<company> company = (List<company>) client.get("AllCompany");
   logger.info("查询出的缓存值为" + company);

   if (company != null) {
       logger.info("返回缓存");
       return company;

   } else {

       logger.info("缓存为空，现在从数据库查询数据");
       List<company> companys = companyMapper.allCompany();
       logger.info("从数据库中查询处的数据为" + companys);

           logger.info("把数据放入缓存");
           boolean state = client.set("AllCompany",companys);
           logger.info("添加新缓存是否成功" + state);

       return companys;
   }
}


//带缓存的countCompany
@Override
public int MemCountCompany() {

   try{
       int rs = (int) client.get("countCompany");
       logger.info("有缓存，缓存为"+rs+"现在开始返回缓存");
       return rs;

   }catch (Exception e){

       //如果缓存为空   返回缓存数据
       logger.info("没有缓存,现在从数据库查询数据");
       int rss = companyMapper.countCompany();
       logger.info("从数据库中查询处的数据为" + rss);

       logger.info("现在开始把数据放入缓存");
       boolean state = client.set("countCompany", rss);
       logger.info("添加新缓存是否成功" + state);
       return rss;
   }
}

studentServiceImpl  仨

//不带缓存的countStudent
@Override
public int countStudent() { 
return studentMapper.countStudent(); }

//带缓存的countStudent
@Override
public int MemCountStudent() {

   try{
   int rs = (int) client.get("countStudent");
   logger.info("有缓存，缓存为"+rs+"现在开始返回缓存");
   return rs;

   }catch (Exception e){

       //如果缓存为空   返回缓存数据
       logger.info("没有缓存,现在从数据库查询数据");
       int rss = studentMapper.countStudent();
       logger.info("从数据库中查询处的数据为" + rss);

       logger.info("现在开始把数据放入缓存");
       boolean state = client.set("countStudent", rss);
       logger.info("添加新缓存是否成功" + state);
       return rss;
   }
}

//不带缓存
@Override
public int countSatisfiedSalary() {
   return studentMapper.countSatisfiedSalary();
}

//带缓存
@Override
public int MemCountSatisfiedSalary() {
   try{
       int rs = (int) client.get("countSalary");
       logger.info("有缓存，缓存为"+rs+"现在开始返回缓存");
       return rs;

   }catch (Exception e){

       //如果缓存为空   返回缓存数据
       logger.info("没有缓存,现在从数据库查询数据");
       int rss = studentMapper.countSatisfiedSalary();
       logger.info("从数据库中查询处的数据为" + rss);

       logger.info("现在开始把数据放入缓存");
       boolean state = client.set("countSalary", rss);
       logger.info("添加新缓存是否成功" + state);
       return rss;
   }
}

//不带缓存
@Override
public List<student> allStudent() {
   return studentMapper.allStudent();
}


//带缓存
@Override
public List<student> MemAllStudent() {

   //取出所有学生的缓存
   List<student> student = (List<student>) client.get("student");
   logger.info("查询出的缓存值为" + student);

   if (student != null) {
       logger.info("返回缓存");
       return student;

   } else {

       logger.info("缓存为空，现在从数据库查询数据");
       List<student> students = studentMapper.allStudent();
       logger.info("从数据库中查询处的数据为" + students);

       try {
           logger.info("把数据放入缓存");
           boolean state = client.set("student", students);
           logger.info("添加新缓存是否成功" + state);
       }catch (Exception e){
           e.printStackTrace();
       }
       return students;
   }
}

今日问题 暂无