动态代理

最新推荐文章于 2019-08-24 09:16:09 发布

weixin_42075672

最新推荐文章于 2019-08-24 09:16:09 发布

阅读量94

点赞数

分类专栏： Java基础文章标签：动态代理全局乱码解决

本文链接：https://blog.csdn.net/weixin_42075672/article/details/82893965

版权

Java基础专栏收录该内容

1 篇文章 0 订阅

订阅专栏

今天在码农翻身看到一篇文章，主要是建议我们进行写作，写作有助于我们深入理解知识，在写作的过程中不断地引导自己对某些东西深入思考，这样就会发现很多我们自以为已经掌握了的细节。正好这两天简单学习了如何使用动态代理，做一下浅显的总结，以后深入了解再来补充。
凡事三问：是什么，干什么，怎么干? 说动态代理之前先说说代理。
1.代理是什么？
没有很好的总结性话语，自己找了个租房的栗子：

被代理类（委托类、目标类）：房东-----真正有房的人
代理类：中介-----他将客户的需求传达给房东，并可以在需求上进行额外的操作
客户类：租房者-----他有需求

2.为什么要出现代理，它可以为我们做什么?

就像租房一样，房东要出租房子，但是他懒得出去张罗，中介可以帮租房者找到他想要的房子，但是要收取提成。在代码中，本来是客户类A想要实现某个功能，就去调用目标类C中的某个方法X；有了代理思想以后，就变成了客户类A想要实现某个功能，就去调用代理类B的某个方法，代理类B中被调用的那个方法再去调用能够真正实现功能的目标类C中的方法X。所以从这个过程中可以简单的看出代理的好处：

隐藏了目标类的实现细节，增强了安全性。
实现了客户类与目标类的解耦，以后想增加某些额外的操作就不需要去修改目标类，直接在代理类里面完成就行。

3.怎么实现代理？
代理分为静态代理和动态代理，代理的一个重要前提条件就是代理类和目标类实现了同一个接口（保证他们具有同样的方法名）：

静态代理：在程序运行前代理类就已经存在。
动态代理：程序运行时，在内存中动态地生成代理类。

举一个静态代理例子：
有一个接口，

package proxy;

public interface TentingHouseInterfa {
      public void renting();
}

有一个目标类，可以出租房子：

package proxy;

public class RentingHoseTarget implements RentingHouseInterfa{
      public void renting() {
    	  System.out.println("出租了房子，房价1000");
      }
}

有一个代理类

package proxy;
    
    public class RentingHouseProxy implements RentingHouseInterfa{
        @Override
    	public void renting() {
        	
        	  RentingHoseTarget target=new RentingHoseTarget();
    		//进行了一些额外操作
    		System.out.println("房子变得更好了！");
    		
    		//调用房东的出租房屋的方法
    		target.renting();
    		
    		//进行了一些额外操作
    		System.out.println("我多收取500的中介费！");
    	}
    }

接下来再说动态代理：
同样的，被代理类还是要实现一个接口。动态代理区别于静态代理就是，代理类不是程序员预先写好的，而是在程序运行时在内存中动态生成的，要想实现动态代理，有三个步骤：

实现一个接口，这个接口中定义了可以实现的功能。
新建一个被代理类实现刚才定义的接口。
用Proxy.newProxyInstance(loader, interfaces, h)动态代理类，用获得的代理类对象调用接口中定义的方法就可以实现所需的功能（重点）。

package dynamicProxy;

import java.lang.annotation.Target;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class Test {
	@org.junit.Test
	public void test() {
		
   	   //生成的动态代理类实现了与Target相同的接口，所以可以强转为该接口类型
		TargetInterface newProxyInstance = (TargetInterface) Proxy.newProxyInstance(
			    //与目标类类加载器相同的类加载器
				TargetClass.class.getClassLoader(), 
				//目标类实现的接口的字节码对象数组，因为可能实现了多个接口
				new Class[]{TargetInterface.class},
				// 代理句柄，用匿名内部类的形式生成的
				new InvocationHandler() {
					@Override
					//invoke  代表调用目标类的方法
					//method  要执行的目标类的方法字节码对象
					//args    要传给目标类方法的参数
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                      //执行目标对象的方法
						method.invoke(new TargetClass(), args);
						return null;
					}
				});
		//用代理类执行实现接口里面定义好的方法
		  newProxyInstance.method1();
		}	
}

以上是一个语法说明，下面列举一个在实际开发中用到案例，全局的乱码处理：
实现的原理是：

如果配置了filter，访问filter匹配路径的资源都要先经过filter的doFilter(ServletRequest
request, ServletResponse response, FilterChain chain)，
并且上面的request对象和response对象是代表封装了HTTP请求和响应的对象，我们可以对request对象和response对象进行加工，然后再放行给servlet，servlet中使用的response和request使用的就是经过我们加工的对象。
我们一般获取前端参数是调用httpservletrequest的getParameter(String name)方法（还有其它的获取参数方法，我们这里只举一个例子），如果我们有一个代理类对getParameter这个方法进行增强（解决乱码），并且把代理类交给servlet使用，那么以后sevlet中使用的都是代理类中的方法（即可以解决乱码的方法）。

首先注册一个filter，让访问目标资源的请求都要经过它：
在web.xml中：

<filter>
    <filter-name>encodingFilter</filter-name>
    <filter-class>liyi.com.web.filter.EncodingFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>encodingFilter</filter-name> 
    <!-- 访问所有资源都要先经过filter处理--> 
    <url-pattern>/*</url-pattern>
  </filter-mapping>

接着在filter中用动态代理实现乱码的解决：

package liyi.com.web.filter;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
public class EncodingFilter implements Filter{

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		// TODO Auto-generated method stub
		
	}
	
	//doFilter方法：会获得代表封装了请求和响应的两个参数（ServletRequest 和ServletResponse ）
	@Override
	public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
			throws IOException, ServletException {
		
		//HttpServletRequest 是ServletRequest 的子类，实现了更多的方法（getSession等）
		HttpServletRequest req=(HttpServletRequest)request;

		//这里就是实现动态代理的具体代码
		HttpServletRequest  httpServletRequest=(HttpServletRequest)Proxy.newProxyInstance(
				req.getClass().getClassLoader(),  //与被代理类（req）相同的类加载
				req.getClass().getInterfaces(),   //req实现的所有接口的数组集合
				new InvocationHandler() {
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						 //因为我们这里只增强getParameter方法，所以先判断
						if("getParameter".equals(method.getName())) {
							//执行了正常的req.getParameter方法，得到的是乱码参数
							String valueluan=(String)method.invoke(req, args);
							//对乱码进行处理
							String value=new String(valueluan.getBytes("ISO8859-1"),"UTF-8");
				            //返回处理后的值
							return value;
						}
						//其他未增强的方法就正常调用、正常返回结果
						return method.invoke(req, args);
					}
				});
		//处理完毕，放行请求，并且将代理类传递给后续的servlet使用，当servlet中使用request.getParameter时使用的就是增强过的方法
		chain.doFilter(httpServletRequest, response);	
	}

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

}

现在只是简单总结了动态代理的思想和使用，以后有了更深层次的理解再回来补充。。。