AOP无法切入同类调用方法的解决办法

@Controller
@RequestMapping("/redis")
public class RedisAction extends BaseAction {

    @Autowired
    private RedisService redisService;

    @Autowired
    private SysUserService sysUserService;

    @RequestMapping("/ValueOperations.do")
    @ControllerLog(module = "redis缓存", methods = "ValueOperations", description = "ValueOperations")
    public void ValueOperations() throws Exception {
        redisService.setCacheObject("xxx","xxx");
        System.out.println(redisService.getCacheObject("xxx").toString());
        SysUser user = getSysUser("zxm");
        redisService.setCacheObject("zxm",user);
        SysUser sysUser = redisService.getCacheObject("zxm");
        System.out.println(sysUser.getUserName());

        SysUser user1 = sysUserService.getSysUser("sqadmin");
        redisService.setCacheObject("sqadmin",user1);
        SysUser sysUser1 = redisService.getCacheObject("sqadmin");
        System.out.println(sysUser1.getUserName());

        ((RedisAction) SpringContextUtil.getCurrentProxy()).getSysUser("zxm");
        SpringContextUtil.getBeanByName(RedisAction.class).deleteSysUser("zxm");

    }

    @RequestMapping("/ListOperations.do")
    @ControllerLog(module = "redis缓存", methods = "ListOperations", description = "ListOperations")
    public void ListOperations() throws Exception {
        SearchContext searchContext = new SearchContext();
        List<SysUser> sysUserList = sysUserService.query(SysUser.class,searchContext);
        redisService.setCacheList("dataList",sysUserList);
        List<SysFunctionPerm> sysFunctionPermList = sysUserService.query(SysFunctionPerm.class,searchContext);
        redisService.setCacheList("sysFunctionPermList",sysFunctionPermList);
        List<SysUserRole> SysUserRoleList = sysUserService.query(SysUserRole.class,searchContext);
        redisService.setCacheList("SysUserRoleList",SysUserRoleList);
        List<SysUser> list = redisService.getCacheList("dataList");
        for(SysUser sysUser:list){
            System.out.println(sysUser.getUserName());
        }
    }

    @RequestMapping("/HashOperations.do")
    @ControllerLog(module = "redis缓存", methods = "HashOperations", description = "HashOperations")
    public void HashOperations() throws Exception {
        SearchContext searchContext = new SearchContext();
        List<SysUser> sysUserList = sysUserService.query(SysUser.class,searchContext);
        Map<String,SysUser> map = new LinkedHashMap<String,SysUser>();
        for(SysUser sysUser:sysUserList){
            map.put("userMap"+sysUser.getUserCode(),sysUser);
        }
        redisService.addAllMap("allMap",map,10);
        redisService.setCacheMap("userMap",map);
        redisService.setCacheObject("objectMap",map);
        SysUser sysUser = new SysUser();
        sysUser.setUserCode("xxx");
        sysUser.setUserName("xxx");
        redisService.insertToMap("userMap","userMap"+sysUser.getUserCode(),sysUser);

        redisService.delMapField("userMap","userMap"+sysUser.getUserCode());
        Map<String,SysUser> sysuerMap = redisService.getCacheMap("allMap");
        Map<String,SysUser> sysuerMap2 = redisService.getCacheObject("objectMap");
        for (Map.Entry<String,SysUser> entry : sysuerMap.entrySet()) {
            System.out.println(entry.getKey()+"====="+entry.getValue().getUserName());
        }
        redisService.removeCache("userMap");
        redisService.removeCache("objectMap");
    }

    @RequestMapping("/SetOperations.do")
    @ControllerLog(module = "redis缓存", methods = "SetOperations", description = "SetOperations")
    public void SetOperations() throws Exception {
        SearchContext searchContext = new SearchContext();
        List<SysUser> sysUserList = sysUserService.query(SysUser.class,searchContext);
        Set<SysUser> sysUserSet = new LinkedHashSet<SysUser>();
        for(SysUser sysUser:sysUserList){
            sysUserSet.add(sysUser);
        }
        redisService.setCacheSet("set",sysUserSet);
        Set<SysUser> sysUserSet2 = redisService.getCacheSet("set");
        Iterator<SysUser> it = sysUserSet2.iterator();
        while(it.hasNext()){
           System.out.println(it.next().getUserName());
        }
    }

    @RedisCache(key = "#userCode",timeOut = 100)
    public SysUser getSysUser(String userCode) {
        SysUser sysUser = null;
        try {
            SearchContext sc = new SearchContext();
            sc.addCondition(Property.forName(SysUser.Attr_userCode).eq(userCode.trim()));
            sc.addCondition(Property.forName(SysUser.Attr_deleted).eq("0"));
            sysUser = (SysUser) sysUserService.getBaseDao().uniqueResult(SysUser.class, sc);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sysUser;
    }

    @RedisEvict(key = "zxm")
    public boolean deleteSysUser(String userCode){
        System.out.println(userCode);
       return true;
    }

package com.commom.utils;

import org.apache.log4j.Logger;
import org.springframework.aop.framework.AopContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;


@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static Logger logger = Logger.getLogger(SpringContextUtil.class);
    private static ApplicationContext applicationContext = null;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        logger.info("------SpringContextUtil setApplicationContext-------");
        SpringContextUtil.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 注意 bean name默认 = 类名(首字母小写)
     * 例如: A8sClusterDao = getBean("k8sClusterDao")
     * @param name
     * @return
     * @throws BeansException
     */
    public static Object getBean(String name) throws BeansException {
        return applicationContext.getBean(name);
    }

    /**
     * 根据类名获取到bean
     * @param <T>
     * @param clazz
     * @return
     * @throws BeansException
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBeanByName(Class<T> clazz) throws BeansException {
        try {
            char[] cs=clazz.getSimpleName().toCharArray();
            cs[0] += 32;//首字母大写到小写
            return (T) applicationContext.getBean(String.valueOf(cs));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }

    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.isSingleton(name);
    }

    /**
     * 获取当前代理对象（必须配置expose-proxy="true"）
     * <aop:aspectj-autoproxy proxy-target-class="true"expose-proxy="true"/>
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T> T getCurrentProxy() throws Exception{
         return (T) AopContext.currentProxy();
    }

}