java动态代理使用方法简单介绍

java中的动态代理技术

动态代理技术定义：为其他对象提供一种代理以控制对这个对象的访问，java动态代理机制以巧妙的方式实现了代理模式的设计理念。

简单的动态代理实现

定义一个“李宇春”对象，她会唱歌跳舞

public class LiYuChun implements Person{
   public String sing(){
       System.out.println("春哥在唱歌");
       return "唱完了";
   }
   public String dance(){
       System.out.println("春哥在跳舞");
       return "跳完了";
   }
}

李宇春实现的接口，Person

public interface Person {
    String sing();
    String dance();
}

李宇春的代理类，可以理解为她的经纪人

public class LiYuChunProxy {
//要生成LiYuChun的代理，那么它必须有一个接口，可以把Person当成LiYuChun的“代理人”
private Person chunchun=new LiYuChun();

   public Person getProxy(){
       return (Person) Proxy.newProxyInstance(LiYuChunProxy.class.getClassLoader()
               , chunchun.getClass().getInterfaces(), new InvocationHandler() {
                /*在外面使用person调用时，实际上是使用的下面这个方法
                 * 
                 * proxy：把代理对象它自己传递进来
                 * method：把代理对象当前调用的方法传递进来
                 * args：把方法的参数传递进来
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    //编码指定返回的代理对象干的工作。。。。。。

                    if(method.getName().equals("sing")){
                        System.out.println("先掏出一万块！");
                        return method.invoke(chunchun, args);
                    }
                    if(method.getName().equals("dance")){
                        System.out.println("先掏出两万块！");
                        return method.invoke(chunchun, args);
                    }
                    return null;
                }
            });
   }
}

这样就阻止了外界直接访问LiYuChun,只能通过经纪人来联系

测试结果

public class Test {
  public static void main(String[] args) {
    LiYuChunProxy pro=new LiYuChunProxy();
    Person p=pro.getProxy();

System.out.println(p.sing());
System.out.println(p.dance());
}
}

输出结果如下

先掏出一万块！
春哥在唱歌
唱完了
先掏出两万块！
春哥在跳舞
跳完了

在过滤器中使用动态代理技术

这是一个实现数据压缩的过滤器

@WebFilter(filterName="/GZIPFilter",urlPatterns={"/*"})
public class GZIPFilter implements Filter {


    public void destroy() {
        // TODO Auto-generated method stub
    }

    /**
     * @see Filter#doFilter(ServletRequest, ServletResponse, FilterChain)
     */
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         final  HttpServletRequest req=(HttpServletRequest) request;
         final  HttpServletResponse res=(HttpServletResponse) response;
         final ByteArrayOutputStream bout=new ByteArrayOutputStream();
         final PrintWriter pw=new PrintWriter(new OutputStreamWriter(bout,"UTF-8"));
         //在放行的时候传进Response的代理
        chain.doFilter(request, (ServletResponse) Proxy.newProxyInstance(GZIPFilter.class.getClassLoader(), res.getClass().getInterfaces(), new InvocationHandler() {

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if(method.getName().equals("getWriter")){
                    return pw; 
                }else if(method.getName().equals("getOutputStream")){
                    return new MyServletOutputStream(bout);//将数据放到自己的输出流中
                }else{
                    return method.invoke(res, args);
                }
            }
        }));
        pw.close();
        byte result[]=bout.toByteArray();//拿到目标资源的输出
        System.out.println("原始大小"+result.length);
        ByteArrayOutputStream bo2=new ByteArrayOutputStream();
        GZIPOutputStream gout=new GZIPOutputStream(bo2);
        gout.write(result);
        gout.close();

        byte gzip[]=bo2.toByteArray();//拿到目标资源的压缩数据
        System.out.println("压缩后大小"+gzip.length);
        res.setHeader("content-encoding", "gzip");
        res.setContentLength(gzip.length);
        res.getOutputStream().write(gzip);
    }

    /**
     * @see Filter#init(FilterConfig)
     */
    public void init(FilterConfig fConfig) throws ServletException {
        // TODO Auto-generated method stub
    }

}

class MyServletOutputStream extends ServletOutputStream{

    private ByteArrayOutputStream bout=null;
    public  MyServletOutputStream(ByteArrayOutputStream bout) {
        // TODO Auto-generated constructor stub
        this.bout=bout;
    }
    @Override
    public boolean isReady() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public void setWriteListener(WriteListener arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void write(int b) throws IOException {
        // TODO Auto-generated method stub
        bout.write(b);
    }

}

在使用动态代理的时候，要求使用代理的这个类有自己的接口，因为proxy仅支持interface代理