Spring AOP案例之内容过滤

    我们有这样一个要求，在设置Bean属性的时候，要检查设置内容是否含有fuck和shit这样的脏话，如果有的话，则进行过滤（使用一个简单的算法把脏话变成新的字符），如果没有，则正常设置，如果使用传统方法，首先需要定义一个脏话过滤接口，然后实现这个接口，再设计一个工程类返回这个实现类的实例，在每一个set方法中都调用检查方法，这样不仅会增加代码量，而且给维护带来了噩梦般的体验，我们如果使用AOP的思想进行设计，就显得代码很简洁，很干净 

本文模拟一个编写Blog文章的场景

BlogPositng 这是一个Blog Entity 的接口，其中设置blog body的方法

 

package  ch7.BlogFilter;


public   interface  BlogPosting  ... {
 
  public String getBody();
  public void setBody(String body);
 
}

BlogPostingImpl是BlogPosting接口的实现类，也就是我们的domain对象

 

package  ch7.BlogFilter;

public   class  BlogPostingImpl  implements  BlogPosting  ... {
    private String body;
    public String getBody() ...{    
        return this.body;
    }
    public void setBody(String body) ...{
        this.body=body;
    }
}

BlogManager是blog管理类，通过这个类的set方法设置blog body,这个类也是我们需要通知的类

 

package  ch7.BlogFilter;

public   class  BlogManager  ... {
   private BlogPosting blogPosting;

public BlogPosting getBlogPosting() ...{
    return blogPosting;
}

public void setBlogPosting(BlogPosting blogPosting) ...{
    this.blogPosting = blogPosting;
}
   
}

OnscenityFilter是脏话过滤类的接口

package  ch7.BlogFilter;

public   interface  OnscenityFilter  ... {
    //判断是否有脏话存在
   public boolean containObscenities(String data);
   //把脏话进行数据替换
   public String obfuscateObscenities(String data);
}

ListBasedObscenityFilter是OnscenityFilter的实现类

package  ch7.BlogFilter;

import  java.util.List;
import  java.util.regex.Pattern;
import  java.util.regex.Matcher;

public   class  ListBasedObscenityFilter  implements  OnscenityFilter  ... {
    private List obscenitites=null; //脏话列表，由Spring注入，写在配置文件中
    private Pattern obsecenityPattern=null; //脏话匹配的正则表达式
    public List getObscenitites() ...{
        return obscenitites;
    }

    public void setObscenitites(List obscenitites) ...{
        this.obscenitites = obscenitites;
        buildRegex();
    }
    //编译正则表达式
    private void buildRegex()...{
        StringBuffer sb=new StringBuffer();
        int size=obscenitites.size();
    
        for (int i = 0; i <size; i++) ...{
            if(i!=0)...{
                sb.append("|");
            }
                sb.append("(");
                sb.append(obscenitites.get(i));
                sb.append(")");
            
            
        }
    
        obsecenityPattern =Pattern.compile(sb.toString(),Pattern.CASE_INSENSITIVE);
    }
    
    public Pattern getObsecenityPattern() ...{
        return obsecenityPattern;
    }

    public void setObsecenityPattern(Pattern obsecenityPattern) ...{
        this.obsecenityPattern = obsecenityPattern;
    }

    //判断有无脏话
    public boolean containObscenities(String data) ...{
        Matcher m=obsecenityPattern.matcher(data);
        return m.find();

    }

    //脏话替换
    public String obfuscateObscenities(String data) ...{
        
        Matcher m=obsecenityPattern.matcher(data);
        StringBuffer out=new StringBuffer(data.length());
        while(m.find())...{

            if(m.group(0)!=null)...{
                m.appendReplacement(out, rot13(m.group(0)));
            }
        }
    
        return out.toString();
    }
    
    //ROT13算法
    private String rot13(String in)...{
        char[] chars=in.toCharArray();
        
        for(int x=0;x<chars.length;x++)...{
            char c=chars[x];

            if(c>='a' && c<='m')...{
                c+=13;
                 
            }
            else if(c>='n' && c<='z')...{
                c-=13;
            }
            else if(c>='A' && c<='M')...{
                c+=13;
            }
            else if(c>='N' && c<='Z')...{
                c-=13;
            }
            
            chars[x]=c;
        }
        
        return new String(chars);
    }

}

 

前置通知，当传入对象是BlogPosting的一个实例时，进行脏话判断和处理

 

package  ch7.BlogFilter;

import  java.lang.reflect.Method;

import  org.springframework.aop.MethodBeforeAdvice;

public   class  ObscenityFileterAdvise  implements  MethodBeforeAdvice  ... {
    private OnscenityFilter onscenityFilter;
    public OnscenityFilter getOnscenityFilter() ...{
        return onscenityFilter;
    }
    public void setOnscenityFilter(OnscenityFilter onscenityFilter) ...{
        this.onscenityFilter = onscenityFilter;
    }
    public void before(Method method, Object[] object, Object target)
            throws Throwable ...{
       
        for(int x=0;x<object.length;x++)...{
            
            if(object[0] instanceof BlogPosting)...{
                BlogPosting arg=(BlogPosting)object[x];
                //如果body中有脏话，则进行过滤修改处理
                
                if(onscenityFilter.containObscenities(arg.getBody()))...{
                    arg.setBody(onscenityFilter.obfuscateObscenities(arg.getBody()));
                }
        
            }
        }

    }

}

配置文件：

 

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

   < bean  id ="advise"  class ="ch7.BlogFilter.ObscenityFileterAdvise" >
     < property  name ="onscenityFilter" >
       < bean  class ="ch7.BlogFilter.ListBasedObscenityFilter" >
          < property  name ="obscenitites" >
            <!--  设置脏话列表  -->
              < list >
                 < value > fuck </ value >
                 < value > shit </ value >
              </ list >
          </ property >
       </ bean >
     </ property >
   </ bean >
  
  < bean  id ="blog"  class ="org.springframework.aop.framework.ProxyFactoryBean" >
    < property  name ="interceptorNames" >
      < list >
        < value > advise </ value >
      </ list >
    </ property >
    < property  name ="target" >
      < bean  class ="ch7.BlogFilter.BlogManager" ></ bean >
    </ property >
    <!--  我们代理的是BlogManager类，所以要设置此属性为true  -->
    < property  name ="proxyTargetClass" >
      < value > true </ value >
    </ property >
  </ bean >
 
</ beans >

 

测试代码：

 

package  ch7.BlogFilter;

import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;

public   class  Test  ... {

    /** *//**
     * @param args
     */
    public static void main(String[] args) ...{
        ApplicationContext context=new ClassPathXmlApplicationContext("ch7/BlogFilter/applicationContext.xml");
        
        BlogManager blogManager=(BlogManager)context.getBean("blog");
    
        BlogPostingImpl blog=new BlogPostingImpl();
        blog.setBody("shit! you must be fuck");
        
        blogManager.setBlogPosting(blog);
        System.out.println(blogManager.getBlogPosting().getBody());
    }

}

 

结果：

fuvg! you must be shpx 可以看到，脏话已经被处理过了